diff --git a/.codecov.yml b/.codecov.yml
deleted file mode 100644
index db24720..0000000
--- a/.codecov.yml
+++ /dev/null
@@ -1 +0,0 @@
-comment: off
diff --git a/.eslintrc.js b/.eslintrc.js
new file mode 100644
index 0000000..7e6d446
--- /dev/null
+++ b/.eslintrc.js
@@ -0,0 +1,79 @@
+"use strict"
+
+/** @type {import('eslint').Linter.Config} */
+module.exports = {
+    root: true,
+    extends: "plugin:@eslint-community/mysticatea/es2018",
+    parserOptions: {
+        project: "./tsconfig.eslint.json",
+    },
+    settings: {
+        node: {
+            tryExtensions: [
+                ".js",
+                ".json",
+                ".mjs",
+                ".node",
+                ".ts",
+                ".tsx",
+                ".vue",
+            ],
+        },
+    },
+    rules: {
+        // TSC does this
+        "no-redeclare": "off",
+        // https://github.com/typescript-eslint/typescript-eslint/issues/743
+        "@eslint-community/mysticatea/ts/unbound-method": "off",
+
+        // Temporary disabled rule: Making a type stricter requires a breaking change of the types.
+        "@eslint-community/mysticatea/ts/prefer-readonly-parameter-types":
+            "off",
+        // Should be fixed by `@eslint-community/eslint-plugin-mysticatea`
+        "no-duplicate-imports": "off",
+        "@eslint-community/mysticatea/ts/no-duplicate-imports": [
+            "error",
+            { includeExports: true },
+        ],
+    },
+    overrides: [
+        {
+            files: "./scripts/clone-without-circular.ts",
+            // Temporarily disable these rules until we fix the `any` usage
+            rules: {
+                "@eslint-community/mysticatea/eslint-comments/no-use": "off",
+                "@eslint-community/mysticatea/ts/no-unsafe-argument": "off",
+                "@eslint-community/mysticatea/ts/no-unsafe-assignment": "off",
+                "@eslint-community/mysticatea/ts/no-unsafe-member-access":
+                    "off",
+                "@eslint-community/mysticatea/ts/no-unsafe-return": "off",
+            },
+        },
+        {
+            files: ["./scripts/extract-test262.ts"],
+            // Disables rules that cannot resolve reports due to missing library type definitions.
+            rules: {
+                "@eslint-community/mysticatea/ts/ban-ts-comment": "off",
+                "@eslint-community/mysticatea/ts/no-unsafe-assignment": "off",
+                "@eslint-community/mysticatea/ts/no-unsafe-call": "off",
+                "@eslint-community/mysticatea/ts/naming-convention": "off",
+                "@eslint-community/mysticatea/ts/no-require-imports": "off",
+                "@eslint-community/mysticatea/ts/no-var-requires": "off",
+            },
+        },
+
+        {
+            files: "./src/unicode/ids.ts",
+            rules: {
+                curly: "off",
+                "no-misleading-character-class": "off",
+            },
+        },
+        {
+            files: "./src/unicode/property-data.ts",
+            rules: {
+                "@eslint-community/mysticatea/ts/camelcase": "off",
+            },
+        },
+    ],
+}
diff --git a/.eslintrc.yml b/.eslintrc.yml
deleted file mode 100644
index 3c518e0..0000000
--- a/.eslintrc.yml
+++ /dev/null
@@ -1,18 +0,0 @@
-root: true
-extends:
-  - plugin:@mysticatea/es2018
-
-rules:
-  # tsc does.
-  "no-redeclare": "off"
-  # https://github.com/typescript-eslint/typescript-eslint/issues/743
-  "@mysticatea/ts/unbound-method": "off"
-
-overrides:
-  - files: "./src/unicode/ids.ts"
-    rules:
-      curly: "off"
-      no-misleading-character-class: "off"
-  - files: "./src/unicode/property-data.ts"
-    rules:
-      "@mysticatea/ts/camelcase": "off"
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
deleted file mode 100644
index ce763b1..0000000
--- a/.github/FUNDING.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-github:
-- mysticatea
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..41744f8
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,11 @@
+version: 2
+updates:
+    - package-ecosystem: github-actions
+      directory: /
+      schedule:
+          interval: daily
+
+    - package-ecosystem: npm
+      directory: /
+      schedule:
+          interval: daily
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b36a5f3..7935172 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,31 +1,104 @@
 name: CI
 on:
   push:
-    branches: [master]
+    branches:
+      # default semantic-release branches
+      - +([0-9])?(.{+([0-9]),x}).x
+      - main
+      - next
+      - next-major
+      - beta
+      - alpha
   pull_request:
-    branches: [master]
   schedule:
     - cron: 0 0 * * 0
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: write # to be able to publish a GitHub release
+  id-token: write # to enable use of OIDC for npm provenance
+  issues: write # to be able to comment on released issues
+  pull-requests: write # to be able to comment on released pull requests
+
 jobs:
-  test:
-    name: Test
+  lint:
+    name: ⬣ Lint
     runs-on: ubuntu-latest
+    steps:
+      - name: ⬇️ Checkout repo
+        uses: actions/checkout@v4
+
+      - name: ⎔ Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+
+      - name: 📥 Install dependencies
+        run: npm install
+
+      - name: ▶️ Run lint script
+        run: npm run lint
+
+  test:
+    name: 🧪 Test (Node@${{ matrix.node }})
     strategy:
       matrix:
-        node: [12.x, 10.x, 8.x]
+        node: [12.0.0, 12, 14.0.0, 14, 16.0.0, 16, 17.0.0, 17, 18.0.0, 18, 19, 20]
+    runs-on: ubuntu-latest
     steps:
-      - name: Checkout
-        uses: actions/checkout@v1
-      - name: Install Node.js ${{ matrix.node }}
-        uses: actions/setup-node@v1
+      - name: ⬇️ Checkout repo
+        uses: actions/checkout@v4
+
+      - name: ⎔ Setup Node v${{ matrix.node }}
+        uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node }}
-      - name: Install Packages
+
+      - name: 📥 Install dependencies
+        run: npm install
+
+      - name: ▶️ Run test script
+        run: npm run test
+
+      - name: ⬆️ Upload coverage report
+        uses: codecov/codecov-action@v3
+
+  release:
+    name: 🚀 Release
+    needs: [lint, test]
+    runs-on: ubuntu-latest
+    if: github.repository == 'eslint-community/regexpp' &&
+      contains('refs/heads/main,refs/heads/next,refs/heads/beta,refs/heads/alpha',
+      github.ref) && github.event_name == 'push'
+    steps:
+      - name: ⬇️ Checkout repo
+        uses: actions/checkout@v4
+
+      - name: ⎔ Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+
+      - name: 📥 Install dependencies
         run: npm install
-      - name: Test
-        run: npm test
-      - name: Send Coverage
-        run: npm run -s codecov
+
+      - name: 🚀 Release
+        uses: cycjimmy/semantic-release-action@v4
+        with:
+          semantic_version: 19
+          branches: |
+            [
+              '+([0-9])?(.{+([0-9]),x}).x',
+              'main',
+              'next',
+              'next-major',
+              {name: 'beta', prerelease: true},
+              {name: 'alpha', prerelease: true}
+            ]
         env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_CONFIG_PROVENANCE: true
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
diff --git a/.github/workflows/cron.yml b/.github/workflows/cron.yml
new file mode 100644
index 0000000..dba1c7c
--- /dev/null
+++ b/.github/workflows/cron.yml
@@ -0,0 +1,52 @@
+name: cron
+on:
+  workflow_dispatch: null
+  schedule:
+    - cron: 0 0 * * 0
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  update-unicode-resource:
+    name: update-unicode-resource
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+      - name: Install Packages
+        run: npm install
+      - name: Update
+        run: npm run update:unicode
+      - uses: peter-evans/create-pull-request@c5a7806660adbe173f04e3e038b0ccdcd758773c
+        with:
+          commit-message: "fix: updates unicode resource with latest"
+          branch: update-unicode-resource
+          branch-suffix: timestamp
+          title: "fix: updates unicode resource with latest"
+
+  update-test262:
+    name: update-test262
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+      - name: Install Packages
+        run: npm install
+      - name: Update
+        run: npm run update:test262:extract
+      - uses: peter-evans/create-pull-request@c5a7806660adbe173f04e3e038b0ccdcd758773c
+        with:
+          commit-message: "test: updates test cases extracted from test262"
+          branch: update-test262
+          branch-suffix: timestamp
+          title: "test: updates test cases extracted from test262"
diff --git a/README.md b/README.md
index a5e2e14..9728af5 100644
--- a/README.md
+++ b/README.md
@@ -1,20 +1,19 @@
-# regexpp
+# @eslint-community/regexpp
 
-[![npm version](https://img.shields.io/npm/v/regexpp.svg)](https://www.npmjs.com/package/regexpp)
-[![Downloads/month](https://img.shields.io/npm/dm/regexpp.svg)](http://www.npmtrends.com/regexpp)
-[![Build Status](https://github.com/mysticatea/regexpp/workflows/CI/badge.svg)](https://github.com/mysticatea/regexpp/actions)
-[![codecov](https://codecov.io/gh/mysticatea/regexpp/branch/master/graph/badge.svg)](https://codecov.io/gh/mysticatea/regexpp)
-[![Dependency Status](https://david-dm.org/mysticatea/regexpp.svg)](https://david-dm.org/mysticatea/regexpp)
+[![npm version](https://img.shields.io/npm/v/@eslint-community/regexpp.svg)](https://www.npmjs.com/package/@eslint-community/regexpp)
+[![Downloads/month](https://img.shields.io/npm/dm/@eslint-community/regexpp.svg)](http://www.npmtrends.com/@eslint-community/regexpp)
+[![Build Status](https://github.com/eslint-community/regexpp/workflows/CI/badge.svg)](https://github.com/eslint-community/regexpp/actions)
+[![codecov](https://codecov.io/gh/eslint-community/regexpp/branch/main/graph/badge.svg)](https://codecov.io/gh/eslint-community/regexpp)
 
 A regular expression parser for ECMAScript.
 
 ## 💿 Installation
 
 ```bash
-$ npm install regexpp
+$ npm install @eslint-community/regexpp
 ```
 
-- require Node.js 8 or newer.
+- require Node@^12.0.0 || ^14.0.0 || >=16.0.0.
 
 ## 📖 Usage
 
@@ -27,7 +26,7 @@ import {
     parseRegExpLiteral,
     validateRegExpLiteral,
     visitRegExpAST
-} from "regexpp"
+} from "@eslint-community/regexpp"
 ```
 
 ### parseRegExpLiteral(source, options?)
@@ -80,7 +79,7 @@ Parse a regular expression literal.
 - **Return:**
     - The AST of the regular expression.
 
-#### parser.parsePattern(source, start?, end?, uFlag?)
+#### parser.parsePattern(source, start?, end?, flags?)
 
 Parse a regular expression pattern.
 
@@ -88,7 +87,7 @@ Parse a regular expression pattern.
     - `source` (`string`) The source code to parse. E.g. `"abc"`.
     - `start?` (`number`) The start index in the source code. Default is `0`.
     - `end?` (`number`) The end index in the source code. Default is `source.length`.
-    - `uFlag?` (`boolean`) The flag to enable Unicode mode.
+    - `flags?` (`{ unicode?: boolean, unicodeSets?: boolean }`) The flags to enable Unicode mode, and Unicode Set mode.
 - **Return:**
     - The AST of the regular expression pattern.
 
@@ -119,7 +118,7 @@ Validate a regular expression literal.
     - `start?` (`number`) The start index in the source code. Default is `0`.
     - `end?` (`number`) The end index in the source code. Default is `source.length`.
 
-#### validator.validatePattern(source, start, end, uFlag)
+#### validator.validatePattern(source, start, end, flags)
 
 Validate a regular expression pattern.
 
@@ -127,7 +126,7 @@ Validate a regular expression pattern.
     - `source` (`string`) The source code to validate.
     - `start?` (`number`) The start index in the source code. Default is `0`.
     - `end?` (`number`) The end index in the source code. Default is `source.length`.
-    - `uFlag?` (`boolean`) The flag to enable Unicode mode.
+    - `flags?` (`{ unicode?: boolean, unicodeSets?: boolean }`) The flags to enable Unicode mode, and Unicode Set mode.
 
 #### validator.validateFlags(source, start, end)
 
@@ -154,7 +153,7 @@ Validate a regular expression literal.
 
 ## 📰 Changelog
 
-- [GitHub Releases](https://github.com/mysticatea/regexpp/releases)
+- [GitHub Releases](https://github.com/eslint-community/regexpp/releases)
 
 ## 🍻 Contributing
 
@@ -173,6 +172,6 @@ Please use GitHub's Issues/PRs.
 - `npm run watch` runs tests with `--watch` option.
 
 [`AST.Node`]: src/ast.ts#L4
-[`RegExpParser.Options`]: src/parser.ts#L539
-[`RegExpValidator.Options`]: src/validator.ts#L127
-[`RegExpVisitor.Handlers`]: src/visitor.ts#L204
+[`RegExpParser.Options`]: src/parser.ts#L743
+[`RegExpValidator.Options`]: src/validator.ts#L220
+[`RegExpVisitor.Handlers`]: src/visitor.ts#L291
diff --git a/package.json b/package.json
index 92dadd8..f70b239 100644
--- a/package.json
+++ b/package.json
@@ -1,91 +1,91 @@
 {
-  "name": "regexpp",
-  "version": "3.2.0",
+  "name": "@eslint-community/regexpp",
+  "version": "0.0.0-semantically-released",
   "description": "Regular expression parser for ECMAScript.",
-  "engines": {
-    "node": ">=8"
-  },
-  "main": "index",
-  "files": [
-    "index.*"
+  "keywords": [
+    "regexp",
+    "regular",
+    "expression",
+    "parser",
+    "validator",
+    "ast",
+    "abstract",
+    "syntax",
+    "tree",
+    "ecmascript",
+    "es2015",
+    "es2016",
+    "es2017",
+    "es2018",
+    "es2019",
+    "es2020",
+    "es2021",
+    "annexB"
   ],
+  "homepage": "https://github.com/eslint-community/regexpp#readme",
+  "bugs": {
+    "url": "https://github.com/eslint-community/regexpp/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eslint-community/regexpp"
+  },
+  "license": "MIT",
+  "author": "Toru Nagashima",
   "exports": {
     ".": {
+      "types": "./index.d.ts",
       "import": "./index.mjs",
       "default": "./index.js"
     },
     "./package.json": "./package.json"
   },
-  "dependencies": {},
-  "devDependencies": {
-    "@mysticatea/eslint-plugin": "^11.0.0",
-    "@types/eslint": "^4.16.2",
-    "@types/jsdom": "^12.2.4",
-    "@types/mocha": "^5.2.2",
-    "@types/node": "^12.6.8",
-    "codecov": "^3.5.0",
-    "dts-bundle": "^0.7.3",
-    "eslint": "^6.1.0",
-    "jsdom": "^15.1.1",
-    "mocha": "^6.2.0",
-    "npm-run-all": "^4.1.5",
-    "nyc": "^14.1.1",
-    "rimraf": "^2.6.2",
-    "rollup": "^1.17.0",
-    "rollup-plugin-node-resolve": "^5.2.0",
-    "rollup-plugin-sourcemaps": "^0.4.2",
-    "ts-node": "^8.3.0",
-    "typescript": "^3.5.3"
-  },
+  "main": "index",
+  "files": [
+    "index.*"
+  ],
   "scripts": {
     "prebuild": "npm run -s clean",
     "build": "run-s build:*",
     "build:tsc": "tsc --module es2015",
     "build:rollup": "rollup -c",
-    "build:dts": "dts-bundle --name regexpp --main .temp/index.d.ts --out ../index.d.ts",
+    "build:dts": "npm run -s build:tsc -- --removeComments false && dts-bundle --name @eslint-community/regexpp --main .temp/index.d.ts --out ../index.d.ts && prettier --write index.d.ts",
     "clean": "rimraf .temp index.*",
-    "codecov": "nyc report -r lcovonly && codecov -t ${CODECOV_TOKEN} --disable=gcov",
-    "lint": "eslint scripts src test --ext .ts",
-    "pretest": "run-s build lint",
+    "lint": "eslint . --ext .ts",
     "test": "nyc _mocha \"test/*.ts\" --reporter dot --timeout 10000",
+    "debug": "mocha --require ts-node/register/transpile-only \"test/*.ts\" --reporter dot --timeout 10000",
     "update:test": "ts-node scripts/update-fixtures.ts",
     "update:unicode": "run-s update:unicode:*",
     "update:unicode:ids": "ts-node scripts/update-unicode-ids.ts",
     "update:unicode:props": "ts-node scripts/update-unicode-properties.ts",
-    "preversion": "npm test",
-    "version": "npm run -s build",
+    "update:test262:extract": "ts-node -T scripts/extract-test262.ts",
+    "preversion": "npm test && npm run -s build",
     "postversion": "git push && git push --tags",
     "prewatch": "npm run -s clean",
     "watch": "_mocha \"test/*.ts\" --require ts-node/register --reporter dot --timeout 10000 --watch-extensions ts --watch --growl"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/mysticatea/regexpp.git"
-  },
-  "keywords": [
-    "regexp",
-    "regular",
-    "expression",
-    "parser",
-    "validator",
-    "ast",
-    "abstract",
-    "syntax",
-    "tree",
-    "ecmascript",
-    "es2015",
-    "es2016",
-    "es2017",
-    "es2018",
-    "es2019",
-    "es2020",
-    "annexB"
-  ],
-  "author": "Toru Nagashima (https://github.com/mysticatea)",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/mysticatea/regexpp/issues"
+  "dependencies": {},
+  "devDependencies": {
+    "@eslint-community/eslint-plugin-mysticatea": "^15.5.1",
+    "@rollup/plugin-node-resolve": "^14.1.0",
+    "@types/eslint": "^8.44.3",
+    "@types/jsdom": "^16.2.15",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^12.20.55",
+    "dts-bundle": "^0.7.3",
+    "eslint": "^8.50.0",
+    "js-tokens": "^8.0.2",
+    "jsdom": "^19.0.0",
+    "mocha": "^9.2.2",
+    "npm-run-all2": "^6.2.2",
+    "nyc": "^14.1.1",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.79.1",
+    "rollup-plugin-sourcemaps": "^0.6.3",
+    "ts-node": "^10.9.1",
+    "typescript": "~5.0.2"
   },
-  "homepage": "https://github.com/mysticatea/regexpp#readme",
-  "funding": "https://github.com/sponsors/mysticatea"
+  "engines": {
+    "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+  }
 }
diff --git a/rollup.config.js b/rollup.config.js
index 00431af..59df39c 100644
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -1,4 +1,4 @@
-import resolve from "rollup-plugin-node-resolve"
+import resolve from "@rollup/plugin-node-resolve"
 import sourcemaps from "rollup-plugin-sourcemaps"
 
 export default [
@@ -9,7 +9,6 @@ export default [
             format: "cjs",
             sourcemap: true,
             sourcemapFile: "index.js.map",
-            banner: `/*! @author Toru Nagashima <https://github.com/mysticatea> */`,
         },
         plugins: [sourcemaps(), resolve()],
     },
@@ -20,7 +19,6 @@ export default [
             format: "es",
             sourcemap: true,
             sourcemapFile: "index.mjs.map",
-            banner: `/*! @author Toru Nagashima <https://github.com/mysticatea> */`,
         },
         plugins: [sourcemaps(), resolve()],
     },
diff --git a/scripts/clone-without-circular.ts b/scripts/clone-without-circular.ts
index b5397e8..e26f19e 100644
--- a/scripts/clone-without-circular.ts
+++ b/scripts/clone-without-circular.ts
@@ -35,7 +35,7 @@ function cloneWithoutCircularRec(x: any, pathMap: Map<object, string>): any {
         return x
     }
     if (Array.isArray(x)) {
-        return x.map(el => cloneWithoutCircularRec(el, pathMap))
+        return x.map((el) => cloneWithoutCircularRec(el, pathMap))
     }
 
     const y = {} as any
@@ -58,7 +58,7 @@ function getRelativePath(
         return to
     }
     if (Array.isArray(to)) {
-        return to.map(el => getRelativePath(from, el, pathMap))
+        return to.map((el) => getRelativePath(from, el, pathMap))
     }
 
     const fromPath = pathMap.get(from)!
@@ -66,14 +66,15 @@ function getRelativePath(
     try {
         return `♻️${posix.relative(fromPath, toPath).replace(/\/$/u, "")}`
     } catch (err) {
-        console.error(fromPath, toPath, err.stack)
+        const error = err as Error
+        console.error(fromPath, toPath, error.stack)
         return "💥💥💥💥💥💥💥💥"
     }
 }
 
 export function cloneWithoutCircular(obj: object): object {
     const path: string[] = []
-    const pathMap: Map<object, string> = new Map()
+    const pathMap = new Map<object, string>()
     resolveLocation(obj, path, pathMap)
 
     return cloneWithoutCircularRec(obj, pathMap)
diff --git a/scripts/extract-test262.ts b/scripts/extract-test262.ts
new file mode 100644
index 0000000..0874c0a
--- /dev/null
+++ b/scripts/extract-test262.ts
@@ -0,0 +1,171 @@
+import path from "path"
+import { promises as fs } from "fs"
+import { parseRegExpLiteral } from "../src/index"
+import jsTokens from "js-tokens"
+import { cloneWithoutCircular } from "./clone-without-circular"
+import type { RegExpSyntaxError } from "../src/regexp-syntax-error"
+import { fixturesData } from "../test/fixtures/parser/literal"
+import type { Readable } from "stream"
+import { execSync } from "child_process"
+
+console.log("Installing test262 and test262-stream...")
+
+execSync(
+    "npm install --no-save git+https://github.com/tc39/test262.git test262-stream",
+    { stdio: "inherit" },
+)
+
+console.log("Extracting test262 fixtures...")
+
+const fixturesRoot = path.join(
+    __dirname,
+    "../test/fixtures/parser/literal/test262",
+)
+
+const test262Root = path.dirname(require.resolve("test262/package.json"))
+
+const TestStream = require("test262-stream")
+
+const stream: Readable = new TestStream(test262Root, { omitRuntime: true })
+
+type Test = {
+    file: string
+    contents: string
+    attrs: {
+        features?: string[]
+    }
+}
+
+const testObjects: Test[] = []
+
+stream.on("data", (test: Test) => {
+    if (!test.file.toLocaleLowerCase().includes("regexp")) {
+        return
+    }
+    testObjects.push(test)
+})
+stream.on("end", () => {
+    // eslint-disable-next-line no-void
+    void extractMain()
+})
+
+async function extractMain() {
+    const usedPatterns = new Set<string>()
+    for (const fixture of Object.values(fixturesData)) {
+        for (const pattern of Object.keys(fixture.patterns)) {
+            usedPatterns.add(pattern)
+        }
+    }
+    const extractedFixtures = new Map<
+        string,
+        {
+            _test262FileNames: string[]
+            options: {
+                strict?: boolean
+            }
+            patterns: Record<string, any>
+        }
+    >()
+    for (const test of testObjects.sort((a, b) => {
+        const lengthA = a.attrs.features?.length ?? 999
+        const lengthB = b.attrs.features?.length ?? 999
+        return lengthA - lengthB || compareStr(a.file, b.file)
+    })) {
+        let filePath: string | undefined = undefined
+        if (test.attrs.features && test.attrs.features.length > 0) {
+            filePath = path.join(
+                fixturesRoot,
+                `${[...test.attrs.features]
+                    .sort(compareStr)
+                    .join("-and-")}.json`,
+            )
+        } else {
+            filePath = path.join(fixturesRoot, "not-categorized.json")
+        }
+        let fixture = extractedFixtures.get(filePath)
+
+        if (!fixture) {
+            if (await fileExists(filePath)) {
+                fixture = JSON.parse(await fs.readFile(filePath, "utf8"))
+            }
+            if (!fixture) {
+                fixture = {
+                    _test262FileNames: [],
+                    options: {},
+                    patterns: {},
+                }
+                extractedFixtures.set(filePath, fixture)
+            }
+        }
+        let has = false
+        for (const pattern of extractRegExp(test.contents)) {
+            if (usedPatterns.has(pattern)) {
+                continue
+            }
+            has = true
+            usedPatterns.add(pattern)
+            try {
+                const ast = parseRegExpLiteral(pattern, fixture.options)
+                fixture.patterns[pattern] = { ast: cloneWithoutCircular(ast) }
+            } catch (err) {
+                const error = err as RegExpSyntaxError
+                fixture.patterns[pattern] = {
+                    error: { message: error.message, index: error.index },
+                }
+            }
+        }
+        if (has) {
+            fixture._test262FileNames = [
+                ...fixture._test262FileNames,
+                test.file,
+            ]
+        }
+    }
+    await fs.copyFile(
+        path.join(test262Root, "LICENSE"),
+        path.join(fixturesRoot, "LICENSE"),
+    )
+    for (const [filePath, fixture] of extractedFixtures) {
+        if (Object.keys(fixture.patterns).length === 0) {
+            continue
+        }
+        fixture._test262FileNames = [
+            ...new Set(fixture._test262FileNames),
+        ].sort(compareStr)
+        // @ts-ignore -- ignore
+        fixture.patterns = Object.fromEntries(
+            Object.entries(fixture.patterns).sort((a, b) =>
+                compareStr(a[0], b[0]),
+            ),
+        )
+        await fs.mkdir(path.dirname(filePath), { recursive: true })
+        await fs.writeFile(
+            filePath,
+            JSON.stringify(
+                fixture,
+                (_, v: unknown) => (v === Infinity ? "$$Infinity" : v),
+                2,
+            ),
+        )
+    }
+}
+
+function* extractRegExp(content: string) {
+    for (const token of jsTokens(content)) {
+        if (token.type === "RegularExpressionLiteral") {
+            yield token.value
+        }
+    }
+}
+
+async function fileExists(filepath: string) {
+    try {
+        return (await fs.lstat(filepath)).isFile()
+    } catch (e) {
+        return false
+    }
+}
+
+function compareStr(a: string, b: string) {
+    return a > b ? 1 : a < b ? -1 : 0
+}
diff --git a/scripts/fetch-lines.ts b/scripts/fetch-lines.ts
new file mode 100644
index 0000000..cd87c2b
--- /dev/null
+++ b/scripts/fetch-lines.ts
@@ -0,0 +1,4 @@
+export async function* fetchLines(url: string): AsyncIterable<string> {
+    const response = await fetch(url)
+    yield* (await response.text()).split("\n")
+}
diff --git a/scripts/get-latest-unicode-general-category-values.ts b/scripts/get-latest-unicode-general-category-values.ts
new file mode 100644
index 0000000..46d0f58
--- /dev/null
+++ b/scripts/get-latest-unicode-general-category-values.ts
@@ -0,0 +1,11 @@
+import { getLatestUnicodePropertyValues } from "./get-latest-unicode-property-values"
+
+export async function* getLatestUnicodeGeneralCategoryValues(): AsyncIterable<string> {
+    for await (const value of getLatestUnicodePropertyValues()) {
+        if (value.propertyAlias !== "gc") {
+            continue
+        }
+
+        yield* value.aliases
+    }
+}
diff --git a/scripts/get-latest-unicode-property-values.ts b/scripts/get-latest-unicode-property-values.ts
new file mode 100644
index 0000000..4b9b26c
--- /dev/null
+++ b/scripts/get-latest-unicode-property-values.ts
@@ -0,0 +1,40 @@
+import { fetchLines } from "./fetch-lines"
+
+const DB_URL =
+    "https://unicode.org/Public/UCD/latest/ucd/PropertyValueAliases.txt"
+const logger = console
+export type UnicodePropertyValue = {
+    propertyAlias: string
+    aliases: string[]
+    canonical: string
+}
+let cache: UnicodePropertyValue[] | undefined = undefined
+export async function* getLatestUnicodePropertyValues(): AsyncIterable<UnicodePropertyValue> {
+    logger.log("Fetching data... (%s)", DB_URL)
+    const iterable = cache
+        ? cache
+        : (async function* () {
+              const newCache: UnicodePropertyValue[] = []
+              for await (const line of fetchLines(DB_URL)) {
+                  if (!line || line.startsWith("#")) {
+                      continue
+                  }
+                  const [propertyAlias, alias, canonical, ...remaining] = line
+                      .split("#")[0] // strip comments
+                      .split(";") // split by semicolon
+                      .map((x) => x.trim()) // trim
+
+                  const value: UnicodePropertyValue = {
+                      propertyAlias,
+                      aliases: [canonical, alias, ...remaining],
+                      canonical,
+                  }
+                  newCache.push(value)
+                  yield value
+              }
+              cache = newCache
+          })()
+    for await (const value of iterable) {
+        yield value
+    }
+}
diff --git a/scripts/get-latest-unicode-script-values.ts b/scripts/get-latest-unicode-script-values.ts
new file mode 100644
index 0000000..1ab2397
--- /dev/null
+++ b/scripts/get-latest-unicode-script-values.ts
@@ -0,0 +1,11 @@
+import { getLatestUnicodePropertyValues } from "./get-latest-unicode-property-values"
+
+export async function* getLatestUnicodeScriptValues(): AsyncIterable<string> {
+    for await (const value of getLatestUnicodePropertyValues()) {
+        if (value.propertyAlias !== "sc") {
+            continue
+        }
+
+        yield* value.aliases
+    }
+}
diff --git a/scripts/update-fixtures.ts b/scripts/update-fixtures.ts
index d497a1a..27715ff 100644
--- a/scripts/update-fixtures.ts
+++ b/scripts/update-fixtures.ts
@@ -1,10 +1,12 @@
-import { AST, parseRegExpLiteral, visitRegExpAST } from "../src/index"
+import type { AST } from "../src/index"
+import { parseRegExpLiteral, visitRegExpAST } from "../src/index"
+import type { RegExpSyntaxError } from "../src/regexp-syntax-error"
 import * as Parser from "../test/fixtures/parser/literal"
 import * as Visitor from "../test/fixtures/visitor"
 import { cloneWithoutCircular } from "./clone-without-circular"
 
-for (const filename of Object.keys(Parser.Fixtures)) {
-    const fixture = Parser.Fixtures[filename]
+for (const filename of Object.keys(Parser.fixturesData)) {
+    const fixture = Parser.fixturesData[filename]
     const options = fixture.options
 
     for (const pattern of Object.keys(fixture.patterns)) {
@@ -12,8 +14,9 @@ for (const filename of Object.keys(Parser.Fixtures)) {
             const ast = parseRegExpLiteral(pattern, options)
             fixture.patterns[pattern] = { ast: cloneWithoutCircular(ast) }
         } catch (err) {
+            const error = err as RegExpSyntaxError
             fixture.patterns[pattern] = {
-                error: { message: err.message, index: err.index },
+                error: { message: error.message, index: error.index },
             }
         }
     }
@@ -21,8 +24,8 @@ for (const filename of Object.keys(Parser.Fixtures)) {
     Parser.save()
 }
 
-for (const filename of Object.keys(Visitor.Fixtures)) {
-    const fixture = Visitor.Fixtures[filename]
+for (const filename of Object.keys(Visitor.fixturesData)) {
+    const fixture = Visitor.fixturesData[filename]
     const options = fixture.options
 
     for (const pattern of Object.keys(fixture.patterns)) {
@@ -44,11 +47,18 @@ for (const filename of Object.keys(Visitor.Fixtures)) {
             onCharacterClassEnter: enter,
             onCharacterClassRangeEnter: enter,
             onCharacterSetEnter: enter,
+            onClassIntersectionEnter: enter,
+            onClassStringDisjunctionEnter: enter,
+            onClassSubtractionEnter: enter,
+            onExpressionCharacterClassEnter: enter,
             onFlagsEnter: enter,
             onGroupEnter: enter,
+            onModifierFlagsEnter: enter,
+            onModifiersEnter: enter,
             onPatternEnter: enter,
             onQuantifierEnter: enter,
             onRegExpLiteralEnter: enter,
+            onStringAlternativeEnter: enter,
             onAlternativeLeave: leave,
             onAssertionLeave: leave,
             onBackreferenceLeave: leave,
@@ -57,11 +67,18 @@ for (const filename of Object.keys(Visitor.Fixtures)) {
             onCharacterClassLeave: leave,
             onCharacterClassRangeLeave: leave,
             onCharacterSetLeave: leave,
+            onClassIntersectionLeave: leave,
+            onClassStringDisjunctionLeave: leave,
+            onClassSubtractionLeave: leave,
+            onExpressionCharacterClassLeave: leave,
             onFlagsLeave: leave,
             onGroupLeave: leave,
+            onModifierFlagsLeave: leave,
+            onModifiersLeave: leave,
             onPatternLeave: leave,
             onQuantifierLeave: leave,
             onRegExpLiteralLeave: leave,
+            onStringAlternativeLeave: leave,
         })
 
         fixture.patterns[pattern] = history
diff --git a/scripts/update-unicode-ids.ts b/scripts/update-unicode-ids.ts
index f20a956..210d111 100644
--- a/scripts/update-unicode-ids.ts
+++ b/scripts/update-unicode-ids.ts
@@ -1,25 +1,25 @@
 import fs from "fs"
-import http from "http"
-import { CLIEngine } from "eslint"
+import { ESLint } from "eslint"
+import { fetchLines } from "./fetch-lines"
 
-const DB_URL = "http://unicode.org/Public/UNIDATA/DerivedCoreProperties.txt"
+const DB_URL = "https://unicode.org/Public/UNIDATA/DerivedCoreProperties.txt"
 const FILE_PATH = "src/unicode/ids.ts"
 const ID_START = /^([0-9a-z]+)(?:\.\.([0-9a-z]+))?[^;]*; ID_Start /iu
 const ID_CONTINUE = /^([0-9a-z]+)(?:\.\.([0-9a-z]+))?[^;]*; ID_Continue /iu
 const BORDER = 0x7f
 const logger = console
 
-    // Main
-;(async () => {
+// Main
+const main = async () => {
     let banner = ""
-    const idStartSet: Set<string> = new Set()
+    const idStartSet = new Set<string>()
     const idStartSmall: [number, number][] = []
     const idStartLarge: [number, number][] = []
     const idContinueSmall: [number, number][] = []
     const idContinueLarge: [number, number][] = []
 
     logger.log("Fetching data... (%s)", DB_URL)
-    await processEachLine(line => {
+    for await (const line of fetchLines(DB_URL)) {
         let m: RegExpExecArray | null = null
         if (banner === "") {
             logger.log("Processing data... (%s)", line.slice(2))
@@ -42,7 +42,7 @@ const logger = console
                 idContinueLarge.push([min, max])
             }
         }
-    })
+    }
 
     logger.log("Normalizing data...")
     normalizeRanges(idStartSmall)
@@ -69,11 +69,11 @@ export function isIdContinue(cp: number): boolean {
 }
 
 function isLargeIdStart(cp: number): boolean {
-    return isInRange(cp, largeIdStartRanges || (largeIdStartRanges = initLargeIdStartRanges()))
+    return isInRange(cp, largeIdStartRanges ?? (largeIdStartRanges = initLargeIdStartRanges()))
 }
 
 function isLargeIdContinue(cp: number): boolean {
-    return isInRange(cp, largeIdContinueRanges || (largeIdContinueRanges = initLargeIdContinueRanges()))
+    return isInRange(cp, largeIdContinueRanges ?? (largeIdContinueRanges = initLargeIdContinueRanges()))
 }
 
 function initLargeIdStartRanges(): number[] {
@@ -108,49 +108,25 @@ function restoreRanges(data: string): number[] {
 `
 
     logger.log("Formatting code...")
-    const engine = new CLIEngine({
+    const engine = new ESLint({
         fix: true,
-        rules: { curly: "off" },
+        baseConfig: { rules: { curly: "off" } },
     })
-    const result = engine.executeOnText(code, "ids.ts").results[0]
-    code = result.output || code
+    const [result] = await engine.lintText(code, { filePath: FILE_PATH })
+    code = result.output ?? code
 
     logger.log("Writing '%s'...", FILE_PATH)
     await save(code)
 
     logger.log("Completed!")
-})().catch(error => {
+}
+
+main().catch((err) => {
+    const error = err as Error
     logger.error(error.stack)
     process.exitCode = 1
 })
 
-function processEachLine(cb: (line: string) => void): Promise<void> {
-    return new Promise((resolve, reject) => {
-        http.get(DB_URL, res => {
-            let buffer = ""
-            res.setEncoding("utf8")
-            res.on("data", chunk => {
-                const lines = (buffer + String(chunk)).split("\n")
-                if (lines.length === 1) {
-                    buffer = lines[0]
-                } else {
-                    buffer = lines.pop()!
-                    for (const line of lines) {
-                        cb(line)
-                    }
-                }
-            })
-            res.on("end", () => {
-                if (buffer) {
-                    cb(buffer)
-                }
-                resolve()
-            })
-            res.on("error", reject)
-        }).on("error", reject)
-    })
-}
-
 function normalizeRanges(ranges: [number, number][]): void {
     for (let i = ranges.length - 1; i >= 1; --i) {
         const currRange = ranges[i]
@@ -187,8 +163,12 @@ function makeInitLargeIdRanges(ranges: [number, number][]): string {
 
 function save(content: string): Promise<void> {
     return new Promise((resolve, reject) => {
-        fs.writeFile(FILE_PATH, content, error =>
-            error ? reject(error) : resolve(),
-        )
+        fs.writeFile(FILE_PATH, content, (error) => {
+            if (error) {
+                reject(error)
+            } else {
+                resolve()
+            }
+        })
     })
 }
diff --git a/scripts/update-unicode-properties.ts b/scripts/update-unicode-properties.ts
index fb70a85..43d871c 100644
--- a/scripts/update-unicode-properties.ts
+++ b/scripts/update-unicode-properties.ts
@@ -1,36 +1,77 @@
 import fs from "fs"
-import { JSDOM, DOMWindow } from "jsdom"
-import { CLIEngine } from "eslint"
+import type { DOMWindow } from "jsdom"
+import { JSDOM } from "jsdom"
+import { ESLint } from "eslint"
+import { getLatestUnicodeGeneralCategoryValues } from "./get-latest-unicode-general-category-values"
+import { getLatestUnicodeScriptValues } from "./get-latest-unicode-script-values"
 
-const DataSources = [
+const DATA_SOURCES = [
     {
-        url: "https://www.ecma-international.org/ecma-262/9.0/",
+        url: "https://262.ecma-international.org/9.0",
         version: 2018,
         binProperties: "#table-binary-unicode-properties",
         gcValues: "#table-unicode-general-category-values",
         scValues: "#table-unicode-script-values",
     },
     {
-        url: "https://www.ecma-international.org/ecma-262/10.0/",
+        url: "https://262.ecma-international.org/10.0",
         version: 2019,
         binProperties: "#table-binary-unicode-properties",
         gcValues: "#table-unicode-general-category-values",
         scValues: "#table-unicode-script-values",
     },
     {
-        url: "https://www.ecma-international.org/ecma-262/11.0/",
+        url: "https://262.ecma-international.org/11.0",
         version: 2020,
         binProperties: "#table-binary-unicode-properties",
         gcValues: "#table-unicode-general-category-values",
         scValues: "#table-unicode-script-values",
     },
     {
-        url: "https://tc39.es/ecma262/",
+        url: "https://262.ecma-international.org/12.0",
         version: 2021,
         binProperties: "#table-binary-unicode-properties",
         gcValues: "#table-unicode-general-category-values",
         scValues: "#table-unicode-script-values",
     },
+    {
+        url: "https://tc39.es/ecma262/2022/multipage/text-processing.html",
+        version: 2022,
+        binProperties: "#table-binary-unicode-properties",
+        gcValues: "#table-unicode-general-category-values",
+        scValues: "#table-unicode-script-values",
+    },
+    {
+        url: "https://tc39.es/ecma262/2023/multipage/text-processing.html",
+        version: 2023,
+        binProperties: "#table-binary-unicode-properties",
+        gcValues: getLatestUnicodeGeneralCategoryValues,
+        scValues: getLatestUnicodeScriptValues,
+    },
+    {
+        url: "https://tc39.es/ecma262/2024/multipage/text-processing.html",
+        version: 2024,
+        binProperties: "#table-binary-unicode-properties",
+        gcValues: getLatestUnicodeGeneralCategoryValues,
+        scValues: getLatestUnicodeScriptValues,
+        binPropertiesOfStrings: "#table-binary-unicode-properties-of-strings",
+    },
+    {
+        url: "https://tc39.es/ecma262/2025/multipage/text-processing.html",
+        version: 2025,
+        binProperties: "#table-binary-unicode-properties",
+        gcValues: getLatestUnicodeGeneralCategoryValues,
+        scValues: getLatestUnicodeScriptValues,
+        binPropertiesOfStrings: "#table-binary-unicode-properties-of-strings",
+    },
+    {
+        url: "https://tc39.es/ecma262/multipage/text-processing.html",
+        version: 2026,
+        binProperties: "#table-binary-unicode-properties",
+        gcValues: getLatestUnicodeGeneralCategoryValues,
+        scValues: getLatestUnicodeScriptValues,
+        binPropertiesOfStrings: "#table-binary-unicode-properties-of-strings",
+    },
 ]
 const FILE_PATH = "src/unicode/properties.ts"
 const logger = console
@@ -39,29 +80,33 @@ type Datum = {
     binProperties: string[]
     gcValues: string[]
     scValues: string[]
+    binPropertiesOfStrings: string[]
 }
 
 // Main
 ;(async () => {
-    const data: Record<number, Datum> = Object.create(null)
+    const data: Record<number, Datum> = {}
     const existing = {
         binProperties: new Set<string>(),
         gcValues: new Set<string>(),
         scValues: new Set<string>(),
+        binPropertiesOfStrings: new Set<string>(),
     }
 
     for (const {
         binProperties,
         gcValues,
         scValues,
+        binPropertiesOfStrings,
         url,
         version,
-    } of DataSources) {
+    } of DATA_SOURCES) {
         logger.log("---- ECMAScript %d ----", version)
         const datum: Datum = {
             binProperties: [],
             gcValues: [],
             scValues: [],
+            binPropertiesOfStrings: [],
         }
         data[version] = datum
 
@@ -70,23 +115,39 @@ type Datum = {
             try {
                 logger.log("Fetching data from %o", url)
                 ;({ window } = await JSDOM.fromURL(url))
-            } catch (error) {
+            } catch (err) {
+                const error = err as Error
                 if (!error || error.message !== "Error: socket hang up") {
                     throw error
                 }
                 logger.log(error.message, "then retry.")
-                await new Promise(resolve => setTimeout(resolve, 2000))
+                await new Promise((resolve) => setTimeout(resolve, 2000))
             }
         } while (window == null)
 
         logger.log("Parsing tables")
-        datum.binProperties = collectValues(
+        datum.binProperties = await collectValues(
             window,
             binProperties,
             existing.binProperties,
         )
-        datum.gcValues = collectValues(window, gcValues, existing.gcValues)
-        datum.scValues = collectValues(window, scValues, existing.scValues)
+        datum.gcValues = await collectValues(
+            window,
+            gcValues,
+            existing.gcValues,
+        )
+        datum.scValues = await collectValues(
+            window,
+            scValues,
+            existing.scValues,
+        )
+        if (binPropertiesOfStrings) {
+            datum.binPropertiesOfStrings = await collectValues(
+                window,
+                binPropertiesOfStrings,
+                existing.binPropertiesOfStrings,
+            )
+        }
 
         logger.log("Done")
     }
@@ -99,13 +160,16 @@ ${makeClassDeclarationCode(Object.keys(data))}
 const gcNameSet = new Set(["General_Category", "gc"])
 const scNameSet = new Set(["Script", "Script_Extensions", "sc", "scx"])
 const gcValueSets = new DataSet(${Object.values(data)
-        .map(d => makeDataCode(d.gcValues))
+        .map((d) => makeDataCode(d.gcValues))
         .join(",")})
 const scValueSets = new DataSet(${Object.values(data)
-        .map(d => makeDataCode(d.scValues))
+        .map((d) => makeDataCode(d.scValues))
         .join(",")})
 const binPropertySets = new DataSet(${Object.values(data)
-        .map(d => makeDataCode(d.binProperties))
+        .map((d) => makeDataCode(d.binProperties))
+        .join(",")})
+const binPropertyOfStringsSets = new DataSet(${Object.values(data)
+        .map((d) => makeDataCode(d.binPropertiesOfStrings))
         .join(",")})
 
 export function isValidUnicodeProperty(version: number, name: string, value: string): boolean {
@@ -136,72 +200,111 @@ export function isValidLoneUnicodeProperty(version: number, value: string): bool
         .filter(Boolean)
         .join(" || ")}
 }
+
+export function isValidLoneUnicodePropertyOfString(version: number, value: string): boolean {
+    return ${Object.entries(data)
+        .map(([version, { binPropertiesOfStrings }]) =>
+            makeVerificationCode(
+                version,
+                "binPropertyOfStringsSets",
+                binPropertiesOfStrings,
+            ),
+        )
+        .filter(Boolean)
+        .join(" || ")}
+}
 `
 
     logger.log("Formatting code...")
-    const engine = new CLIEngine({ fix: true })
-    const result = engine.executeOnText(code, "properties.ts").results[0]
-    code = result.output || code
+    const engine = new ESLint({ fix: true })
+    const [result] = await engine.lintText(code, { filePath: FILE_PATH })
+    code = result.output ?? code
 
     logger.log("Writing '%s'...", FILE_PATH)
     await save(code)
 
     logger.log("Completed!")
-})().catch(error => {
+})().catch((err) => {
+    const error = err as Error
     logger.error(error.stack)
     process.exitCode = 1
 })
 
-function collectValues(
-    window: Window,
-    id: string,
+async function collectValues(
+    window: DOMWindow,
+    idSelectorOrProvider: string | (() => AsyncIterable<string>),
     existingSet: Set<string>,
-): string[] {
-    const selector = `${id} td:nth-child(1) code`
-    const nodes = window.document.querySelectorAll(selector)
-    const values = Array.from(nodes, node => node.textContent || "")
-        .filter(value => {
-            if (existingSet.has(value)) {
-                return false
-            }
-            existingSet.add(value)
-            return true
-        })
-        .sort(undefined)
+): Promise<string[]> {
+    const getValues =
+        typeof idSelectorOrProvider === "function"
+            ? idSelectorOrProvider
+            : function* (): Iterable<string> {
+                  const selector = `${idSelectorOrProvider} td:nth-child(1) code`
+                  const nodes = window.document.querySelectorAll(selector)
+                  if (nodes.length === 0) {
+                      throw new Error(`No nodes found for selector ${selector}`)
+                  }
+                  logger.log(
+                      "%o nodes of %o were found.",
+                      nodes.length,
+                      selector,
+                  )
+                  for (const node of Array.from(nodes)) {
+                      yield node.textContent ?? ""
+                  }
+              }
+
+    const missing = new Set(existingSet)
+    const values = new Set<string>()
+    let allCount = 0
+
+    for await (const value of getValues()) {
+        allCount++
+        missing.delete(value)
+        if (existingSet.has(value)) {
+            continue
+        }
+        existingSet.add(value)
+        values.add(value)
+    }
+
+    if (missing.size > 0) {
+        throw new Error(`Missing values: ${Array.from(missing).join(", ")}`)
+    }
 
     logger.log(
-        "%o nodes of %o were found, then %o adopted and %o ignored as duplication.",
-        nodes.length,
-        selector,
-        values.length,
-        nodes.length - values.length,
+        "%o adopted and %o ignored as duplication.",
+        values.size,
+        allCount - values.size,
     )
 
-    return values
+    return [...values].sort((a, b) => (a > b ? 1 : a < b ? -1 : 0))
 }
 
 function makeClassDeclarationCode(versions: string[]): string {
     const fields = versions
         .map(
-            v =>
-                `private _raw${v}: string\nprivate _set${v}: Set<string> | undefined`,
+            (v) =>
+                `private _raw${v}: string\n\nprivate _set${v}: Set<string> | undefined`,
         )
-        .join("\n")
-    const parameters = versions.map(v => `raw${v}: string`).join(", ")
-    const init = versions.map(v => `this._raw${v} = raw${v}`).join("\n")
+        .join("\n\n")
+    const parameters = versions.map((v) => `raw${v}: string`).join(", ")
+    const init = versions.map((v) => `this._raw${v} = raw${v}`).join("\n")
     const getters = versions
         .map(
-            v =>
-                `public get es${v}(): Set<string> { return this._set${v} || (this._set${v} = new Set(this._raw${v}.split(" "))) }`,
+            (v) =>
+                `public get es${v}(): Set<string> { return this._set${v} ?? (this._set${v} = new Set(this._raw${v}.split(" "))) }`,
         )
-        .join("\n")
+        .join("\n\n")
 
     return `
         class DataSet {
             ${fields}
+
             public constructor(${parameters}) {
                 ${init}
             }
+
             ${getters}
         }
     `
@@ -209,7 +312,7 @@ function makeClassDeclarationCode(versions: string[]): string {
 
 function makeDataCode(values: string[]): string {
     return `"${values
-        .map(value => JSON.stringify(value).slice(1, -1))
+        .map((value) => JSON.stringify(value).slice(1, -1))
         .join(" ")}"`
 }
 
@@ -227,8 +330,12 @@ function makeVerificationCode(
 
 function save(content: string): Promise<void> {
     return new Promise((resolve, reject) => {
-        fs.writeFile(FILE_PATH, content, error =>
-            error ? reject(error) : resolve(),
-        )
+        fs.writeFile(FILE_PATH, content, (error) => {
+            if (error) {
+                reject(error)
+            } else {
+                resolve()
+            }
+        })
     })
 }
diff --git a/src/ast.ts b/src/ast.ts
index 5ba597c..75fed3e 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -7,52 +7,70 @@ export type Node = BranchNode | LeafNode
  * The type which includes all branch nodes.
  */
 export type BranchNode =
-    | RegExpLiteral
-    | Pattern
     | Alternative
-    | Group
     | CapturingGroup
-    | Quantifier
     | CharacterClass
-    | LookaroundAssertion
     | CharacterClassRange
+    | ClassIntersection
+    | ClassStringDisjunction
+    | ClassSubtraction
+    | ExpressionCharacterClass
+    | Group
+    | LookaroundAssertion
+    | Modifiers
+    | Pattern
+    | Quantifier
+    | RegExpLiteral
+    | StringAlternative
 
 /**
  * The type which includes all leaf nodes.
  */
 export type LeafNode =
+    | Backreference
     | BoundaryAssertion
-    | CharacterSet
     | Character
-    | Backreference
+    | CharacterSet
     | Flags
+    | ModifierFlags
 
 /**
  * The type which includes all atom nodes.
  */
-export type Element = Assertion | Quantifier | QuantifiableElement
+export type Element = Assertion | QuantifiableElement | Quantifier
 
 /**
  * The type which includes all atom nodes that Quantifier node can have as children.
  */
 export type QuantifiableElement =
-    | Group
+    | Backreference
     | CapturingGroup
+    | Character
     | CharacterClass
     | CharacterSet
-    | Character
-    | Backreference
-    // Lookahead assertions is quantifiable in Annex-B.
+    | ExpressionCharacterClass
+    | Group
     | LookaheadAssertion
 
 /**
  * The type which includes all character class atom nodes.
  */
 export type CharacterClassElement =
+    | ClassRangesCharacterClassElement
+    | UnicodeSetsCharacterClassElement
+export type ClassRangesCharacterClassElement =
+    | Character
+    | CharacterClassRange
+    | CharacterUnicodePropertyCharacterSet
     | EscapeCharacterSet
-    | UnicodePropertyCharacterSet
+export type UnicodeSetsCharacterClassElement =
     | Character
     | CharacterClassRange
+    | ClassStringDisjunction
+    | EscapeCharacterSet
+    | ExpressionCharacterClass
+    | UnicodePropertyCharacterSet
+    | UnicodeSetsCharacterClass
 
 /**
  * The type which defines common properties for all node types.
@@ -95,7 +113,7 @@ export interface Pattern extends NodeBase {
  */
 export interface Alternative extends NodeBase {
     type: "Alternative"
-    parent: Pattern | Group | CapturingGroup | LookaroundAssertion
+    parent: CapturingGroup | Group | LookaroundAssertion | Pattern
     elements: Element[]
 }
 
@@ -106,6 +124,7 @@ export interface Alternative extends NodeBase {
 export interface Group extends NodeBase {
     type: "Group"
     parent: Alternative | Quantifier
+    modifiers: Modifiers | null
     alternatives: Alternative[]
 }
 
@@ -167,12 +186,48 @@ export interface Quantifier extends NodeBase {
  * The character class.
  * E.g. `[ab]`, `[^ab]`
  */
-export interface CharacterClass extends NodeBase {
+export type CharacterClass =
+    | ClassRangesCharacterClass
+    | UnicodeSetsCharacterClass
+interface BaseCharacterClass extends NodeBase {
     type: "CharacterClass"
-    parent: Alternative | Quantifier
+    parent:
+        | Alternative
+        | ClassIntersection
+        | ClassSubtraction
+        | Quantifier
+        | UnicodeSetsCharacterClass
+    unicodeSets: boolean
     negate: boolean
     elements: CharacterClassElement[]
 }
+/**
+ * The character class used in legacy (neither `u` nor `v` flag) and Unicode mode (`u` flag).
+ *
+ * This character class is guaranteed to **not** contain strings.
+ *
+ * In Unicode sets mode (`v` flag), {@link UnicodeSetsCharacterClass} is used.
+ */
+export interface ClassRangesCharacterClass extends BaseCharacterClass {
+    parent: Alternative | Quantifier
+    unicodeSets: false
+    elements: ClassRangesCharacterClassElement[]
+}
+/**
+ * The character class used in Unicode sets mode (`v` flag).
+ *
+ * This character class may contain strings.
+ */
+export interface UnicodeSetsCharacterClass extends BaseCharacterClass {
+    parent:
+        | Alternative
+        | ClassIntersection
+        | ClassSubtraction
+        | Quantifier
+        | UnicodeSetsCharacterClass
+    unicodeSets: true
+    elements: UnicodeSetsCharacterClassElement[]
+}
 
 /**
  * The character class.
@@ -202,7 +257,7 @@ export type BoundaryAssertion = EdgeAssertion | WordBoundaryAssertion
 export interface EdgeAssertion extends NodeBase {
     type: "Assertion"
     parent: Alternative | Quantifier
-    kind: "start" | "end"
+    kind: "end" | "start"
 }
 
 /**
@@ -240,7 +295,12 @@ export interface AnyCharacterSet extends NodeBase {
  */
 export interface EscapeCharacterSet extends NodeBase {
     type: "CharacterSet"
-    parent: Alternative | Quantifier | CharacterClass
+    parent:
+        | Alternative
+        | CharacterClass
+        | ClassIntersection
+        | ClassSubtraction
+        | Quantifier
     kind: "digit" | "space" | "word"
     negate: boolean
 }
@@ -249,14 +309,105 @@ export interface EscapeCharacterSet extends NodeBase {
  * The unicode property escape.
  * E.g. `\p{ASCII}`, `\P{ASCII}`, `\p{Script=Hiragana}`
  */
-export interface UnicodePropertyCharacterSet extends NodeBase {
+export type UnicodePropertyCharacterSet =
+    | CharacterUnicodePropertyCharacterSet
+    | StringsUnicodePropertyCharacterSet
+interface BaseUnicodePropertyCharacterSet extends NodeBase {
     type: "CharacterSet"
-    parent: Alternative | Quantifier | CharacterClass
+    parent:
+        | Alternative
+        | CharacterClass
+        | ClassIntersection
+        | ClassSubtraction
+        | Quantifier
     kind: "property"
+    strings: boolean
     key: string
     value: string | null
     negate: boolean
 }
+export interface CharacterUnicodePropertyCharacterSet
+    extends BaseUnicodePropertyCharacterSet {
+    strings: false
+    value: string | null
+    negate: boolean
+}
+/** StringsUnicodePropertyCharacterSet is Unicode property escape with property of strings. */
+export interface StringsUnicodePropertyCharacterSet
+    extends BaseUnicodePropertyCharacterSet {
+    parent:
+        | Alternative
+        | ClassIntersection
+        | ClassSubtraction
+        | Quantifier
+        | UnicodeSetsCharacterClass
+    strings: true
+    value: null
+    negate: false
+}
+
+/**
+ * The expression character class.
+ * E.g. `[a--b]`, `[a&&b]`,`[^a--b]`, `[^a&&b]`
+ */
+export interface ExpressionCharacterClass extends NodeBase {
+    type: "ExpressionCharacterClass"
+    parent:
+        | Alternative
+        | ClassIntersection
+        | ClassSubtraction
+        | Quantifier
+        | UnicodeSetsCharacterClass
+    negate: boolean
+    expression: ClassIntersection | ClassSubtraction
+}
+
+export type ClassSetOperand =
+    | Character
+    | ClassStringDisjunction
+    | EscapeCharacterSet
+    | ExpressionCharacterClass
+    | UnicodePropertyCharacterSet
+    | UnicodeSetsCharacterClass
+
+/**
+ * The character class intersection.
+ * E.g. `a&&b`
+ */
+export interface ClassIntersection extends NodeBase {
+    type: "ClassIntersection"
+    parent: ClassIntersection | ExpressionCharacterClass
+    left: ClassIntersection | ClassSetOperand
+    right: ClassSetOperand
+}
+
+/**
+ * The character class subtraction.
+ * E.g. `a--b`
+ */
+export interface ClassSubtraction extends NodeBase {
+    type: "ClassSubtraction"
+    parent: ClassSubtraction | ExpressionCharacterClass
+    left: ClassSetOperand | ClassSubtraction
+    right: ClassSetOperand
+}
+
+/**
+ * The character class string disjunction.
+ * E.g. `\q{a|b}`
+ */
+export interface ClassStringDisjunction extends NodeBase {
+    type: "ClassStringDisjunction"
+    parent: ClassIntersection | ClassSubtraction | UnicodeSetsCharacterClass
+    alternatives: StringAlternative[]
+}
+
+/** StringAlternative is only used for `\q{alt}`({@link ClassStringDisjunction}). */
+export interface StringAlternative extends NodeBase {
+    type: "StringAlternative"
+    parent: ClassStringDisjunction
+    elements: Character[]
+}
 
 /**
  * The character.
@@ -265,7 +416,14 @@ export interface UnicodePropertyCharacterSet extends NodeBase {
  */
 export interface Character extends NodeBase {
     type: "Character"
-    parent: Alternative | Quantifier | CharacterClass | CharacterClassRange
+    parent:
+        | Alternative
+        | CharacterClass
+        | CharacterClassRange
+        | ClassIntersection
+        | ClassSubtraction
+        | Quantifier
+        | StringAlternative
     value: number // a code point.
 }
 
@@ -273,13 +431,54 @@ export interface Character extends NodeBase {
  * The backreference.
  * E.g. `\1`, `\k<name>`
  */
-export interface Backreference extends NodeBase {
+export type Backreference = AmbiguousBackreference | UnambiguousBackreference
+interface BaseBackreference extends NodeBase {
     type: "Backreference"
     parent: Alternative | Quantifier
     ref: number | string
+    ambiguous: boolean
+    resolved: CapturingGroup | CapturingGroup[]
+}
+export interface AmbiguousBackreference extends BaseBackreference {
+    ref: string
+    ambiguous: true
+    resolved: CapturingGroup[]
+}
+export interface UnambiguousBackreference extends BaseBackreference {
+    ambiguous: false
     resolved: CapturingGroup
 }
 
+/**
+ * The modifiers.
+ */
+export interface Modifiers extends NodeBase {
+    type: "Modifiers"
+    parent: Group
+    /**
+     * The add modifier flags.
+     */
+    add: ModifierFlags
+    /**
+     * The remove modifier flags.
+     *
+     * `null` means no remove modifier flags. e.g. `(?ims:x)`
+     * The reason for `null` is that there is no position where the remove modifier flags appears. Must be behind the minus mark.
+     */
+    remove: ModifierFlags | null
+}
+
+/**
+ * The modifier flags.
+ */
+export interface ModifierFlags extends NodeBase {
+    type: "ModifierFlags"
+    parent: Modifiers
+    dotAll: boolean
+    ignoreCase: boolean
+    multiline: boolean
+}
+
 /**
  * The flags.
  */
@@ -293,4 +492,5 @@ export interface Flags extends NodeBase {
     multiline: boolean
     sticky: boolean
     unicode: boolean
+    unicodeSets: boolean
 }
diff --git a/src/ecma-versions.ts b/src/ecma-versions.ts
index 53dce83..3a6b1d9 100644
--- a/src/ecma-versions.ts
+++ b/src/ecma-versions.ts
@@ -8,3 +8,7 @@ export type EcmaVersion =
     | 2020
     | 2021
     | 2022
+    | 2023
+    | 2024
+    | 2025
+export const latestEcmaVersion = 2025
diff --git a/src/group-specifiers.ts b/src/group-specifiers.ts
new file mode 100644
index 0000000..e26329b
--- /dev/null
+++ b/src/group-specifiers.ts
@@ -0,0 +1,167 @@
+/**
+ * Holds information for all GroupSpecifiers included in the pattern.
+ */
+export interface GroupSpecifiers {
+    /**
+     * @returns true if there are no GroupSpecifiers included in the pattern.
+     */
+    isEmpty: () => boolean
+    clear: () => void
+    /**
+     * Called when visiting the Disjunction.
+     * For ES2025, manage nesting with new Disjunction scopes.
+     */
+    enterDisjunction: () => void
+    /**
+     * Called when visiting the Alternative.
+     * For ES2025, manage nesting with new Alternative scopes.
+     */
+    enterAlternative: (index: number) => void
+    /**
+     * Called when leaving the Disjunction.
+     */
+    leaveDisjunction: () => unknown
+    /**
+     * Checks whether the given group name is within the pattern.
+     */
+    hasInPattern: (name: string) => boolean
+    /**
+     * Checks whether the given group name is within the current scope.
+     */
+    hasInScope: (name: string) => boolean
+    /**
+     * Adds the given group name to the current scope.
+     */
+    addToScope: (name: string) => void
+}
+
+export class GroupSpecifiersAsES2018 implements GroupSpecifiers {
+    private readonly groupName = new Set<string>()
+
+    public clear(): void {
+        this.groupName.clear()
+    }
+
+    public isEmpty(): boolean {
+        return !this.groupName.size
+    }
+
+    public hasInPattern(name: string): boolean {
+        return this.groupName.has(name)
+    }
+
+    public hasInScope(name: string): boolean {
+        return this.hasInPattern(name)
+    }
+
+    public addToScope(name: string): void {
+        this.groupName.add(name)
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    public enterDisjunction(): void {
+        // Prior to ES2025, it does not manage disjunction scopes.
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    public enterAlternative(): void {
+        // Prior to ES2025, it does not manage alternative scopes.
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    public leaveDisjunction(): void {
+        // Prior to ES2025, it does not manage disjunction scopes.
+    }
+}
+
+/**
+ * Track disjunction structure to determine whether a duplicate
+ * capture group name is allowed because it is in a separate branch.
+ */
+class BranchID {
+    public readonly parent: BranchID | null
+    private readonly base: BranchID
+    public constructor(parent: BranchID | null, base: BranchID | null) {
+        // Parent disjunction branch
+        this.parent = parent
+        // Identifies this set of sibling branches
+        this.base = base ?? this
+    }
+
+    /**
+     * A branch is separate from another branch if they or any of
+     * their parents are siblings in a given disjunction
+     */
+    public separatedFrom(other: BranchID): boolean {
+        if (this.base === other.base && this !== other) {
+            return true
+        }
+        if (other.parent && this.separatedFrom(other.parent)) {
+            return true
+        }
+        return this.parent?.separatedFrom(other) ?? false
+    }
+
+    public child() {
+        return new BranchID(this, null)
+    }
+
+    public sibling() {
+        return new BranchID(this.parent, this.base)
+    }
+}
+
+export class GroupSpecifiersAsES2025 implements GroupSpecifiers {
+    private branchID = new BranchID(null, null)
+    private readonly groupNames = new Map<string, BranchID[]>()
+
+    public clear(): void {
+        this.branchID = new BranchID(null, null)
+        this.groupNames.clear()
+    }
+
+    public isEmpty(): boolean {
+        return !this.groupNames.size
+    }
+
+    public enterDisjunction(): void {
+        this.branchID = this.branchID.child()
+    }
+
+    public enterAlternative(index: number): void {
+        if (index === 0) {
+            return
+        }
+        this.branchID = this.branchID.sibling()
+    }
+
+    public leaveDisjunction(): void {
+        this.branchID = this.branchID.parent!
+    }
+
+    public hasInPattern(name: string): boolean {
+        return this.groupNames.has(name)
+    }
+
+    public hasInScope(name: string): boolean {
+        const branches = this.groupNames.get(name)
+        if (!branches) {
+            return false
+        }
+        for (const branch of branches) {
+            if (!branch.separatedFrom(this.branchID)) {
+                return true
+            }
+        }
+        return false
+    }
+
+    public addToScope(name: string): void {
+        const branches = this.groupNames.get(name)
+        if (branches) {
+            branches.push(this.branchID)
+            return
+        }
+        this.groupNames.set(name, [this.branchID])
+    }
+}
diff --git a/src/index.ts b/src/index.ts
index 0b6bac5..e199813 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -3,6 +3,7 @@ import { RegExpParser } from "./parser"
 import { RegExpValidator } from "./validator"
 import { RegExpVisitor } from "./visitor"
 
+export { RegExpSyntaxError } from "./regexp-syntax-error"
 export { AST, RegExpParser, RegExpValidator }
 
 /**
@@ -12,7 +13,7 @@ export { AST, RegExpParser, RegExpValidator }
  * @returns The AST of the regular expression.
  */
 export function parseRegExpLiteral(
-    source: string | RegExp,
+    source: RegExp | string,
     options?: RegExpParser.Options,
 ): AST.RegExpLiteral {
     return new RegExpParser(options).parseLiteral(String(source))
@@ -27,7 +28,7 @@ export function validateRegExpLiteral(
     source: string,
     options?: RegExpValidator.Options,
 ): void {
-    return new RegExpValidator(options).validateLiteral(source)
+    new RegExpValidator(options).validateLiteral(source)
 }
 
 export function visitRegExpAST(
diff --git a/src/parser.ts b/src/parser.ts
index 3bc795f..9f25b59 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -1,9 +1,8 @@
-import {
+import type {
     Alternative,
     Backreference,
     CapturingGroup,
     CharacterClass,
-    CharacterClassElement,
     CharacterClassRange,
     Flags,
     Group,
@@ -11,36 +10,71 @@ import {
     LookaroundAssertion,
     Pattern,
     Quantifier,
+    ClassStringDisjunction,
+    ClassIntersection,
+    ClassSubtraction,
+    UnicodeSetsCharacterClassElement,
+    ClassSetOperand,
+    UnicodeSetsCharacterClass,
+    ExpressionCharacterClass,
+    StringAlternative,
+    Modifiers,
 } from "./ast"
-import { EcmaVersion } from "./ecma-versions"
-import { HyphenMinus } from "./unicode"
+import type { EcmaVersion } from "./ecma-versions"
+import { latestEcmaVersion } from "./ecma-versions"
+import { HYPHEN_MINUS } from "./unicode"
 import { RegExpValidator } from "./validator"
 
 type AppendableNode =
-    | Pattern
     | Alternative
-    | Group
     | CapturingGroup
     | CharacterClass
+    | ClassStringDisjunction
+    | Group
     | LookaroundAssertion
-
-const DummyPattern: Pattern = {} as any
-const DummyFlags: Flags = {} as any
-const DummyCapturingGroup: CapturingGroup = {} as any
+    | Modifiers
+    | Pattern
+    | StringAlternative
+
+const DUMMY_PATTERN: Pattern = {} as Pattern
+const DUMMY_FLAGS: Flags = {} as Flags
+const DUMMY_CAPTURING_GROUP: CapturingGroup = {} as CapturingGroup
+
+function isClassSetOperand(
+    node: UnicodeSetsCharacterClassElement,
+): node is ClassSetOperand {
+    return (
+        node.type === "Character" ||
+        node.type === "CharacterSet" ||
+        node.type === "CharacterClass" ||
+        node.type === "ExpressionCharacterClass" ||
+        node.type === "ClassStringDisjunction"
+    )
+}
 
 class RegExpParserState {
     public readonly strict: boolean
+
     public readonly ecmaVersion: EcmaVersion
-    private _node: AppendableNode = DummyPattern
-    private _flags: Flags = DummyFlags
+
+    private _node: AppendableNode = DUMMY_PATTERN
+
+    private _expressionBufferMap = new Map<
+        CharacterClass | ExpressionCharacterClass,
+        ClassIntersection | ClassSubtraction
+    >()
+
+    private _flags: Flags = DUMMY_FLAGS
+
     private _backreferences: Backreference[] = []
+
     private _capturingGroups: CapturingGroup[] = []
 
     public source = ""
 
     public constructor(options?: RegExpParser.Options) {
-        this.strict = Boolean(options && options.strict)
-        this.ecmaVersion = (options && options.ecmaVersion) || 2022
+        this.strict = Boolean(options?.strict)
+        this.ecmaVersion = options?.ecmaVersion ?? latestEcmaVersion
     }
 
     public get pattern(): Pattern {
@@ -57,16 +91,28 @@ class RegExpParserState {
         return this._flags
     }
 
-    public onFlags(
+    public onRegExpFlags(
         start: number,
         end: number,
-        global: boolean,
-        ignoreCase: boolean,
-        multiline: boolean,
-        unicode: boolean,
-        sticky: boolean,
-        dotAll: boolean,
-        hasIndices: boolean,
+        {
+            global,
+            ignoreCase,
+            multiline,
+            unicode,
+            sticky,
+            dotAll,
+            hasIndices,
+            unicodeSets,
+        }: {
+            global: boolean
+            ignoreCase: boolean
+            multiline: boolean
+            unicode: boolean
+            sticky: boolean
+            dotAll: boolean
+            hasIndices: boolean
+            unicodeSets: boolean
+        },
     ): void {
         this._flags = {
             type: "Flags",
@@ -81,6 +127,7 @@ class RegExpParserState {
             sticky,
             dotAll,
             hasIndices,
+            unicodeSets,
         }
     }
 
@@ -103,12 +150,21 @@ class RegExpParserState {
 
         for (const reference of this._backreferences) {
             const ref = reference.ref
-            const group =
+            const groups =
                 typeof ref === "number"
-                    ? this._capturingGroups[ref - 1]
-                    : this._capturingGroups.find(g => g.name === ref)!
-            reference.resolved = group
-            group.references.push(reference)
+                    ? [this._capturingGroups[ref - 1]]
+                    : this._capturingGroups.filter((g) => g.name === ref)
+            if (groups.length === 1) {
+                const group = groups[0]
+                reference.ambiguous = false
+                reference.resolved = group
+            } else {
+                reference.ambiguous = true
+                reference.resolved = groups
+            }
+            for (const group of groups) {
+                group.references.push(reference)
+            }
         }
     }
 
@@ -151,14 +207,17 @@ class RegExpParserState {
             throw new Error("UnknownError")
         }
 
-        this._node = {
+        const group: Group = {
             type: "Group",
             parent,
             start,
             end: start,
             raw: "",
+            modifiers: null,
             alternatives: [],
         }
+
+        this._node = group
         parent.elements.push(this._node)
     }
 
@@ -173,6 +232,85 @@ class RegExpParserState {
         this._node = node.parent
     }
 
+    public onModifiersEnter(start: number): void {
+        const parent = this._node
+        if (parent.type !== "Group") {
+            throw new Error("UnknownError")
+        }
+
+        this._node = {
+            type: "Modifiers",
+            parent,
+            start,
+            end: start,
+            raw: "",
+            add: null as never, // Set in onAddModifiers.
+            remove: null,
+        }
+        parent.modifiers = this._node
+    }
+
+    public onModifiersLeave(start: number, end: number): void {
+        const node = this._node
+        if (node.type !== "Modifiers" || node.parent.type !== "Group") {
+            throw new Error("UnknownError")
+        }
+
+        node.end = end
+        node.raw = this.source.slice(start, end)
+        this._node = node.parent
+    }
+
+    public onAddModifiers(
+        start: number,
+        end: number,
+        {
+            ignoreCase,
+            multiline,
+            dotAll,
+        }: { ignoreCase: boolean; multiline: boolean; dotAll: boolean },
+    ): void {
+        const parent = this._node
+        if (parent.type !== "Modifiers") {
+            throw new Error("UnknownError")
+        }
+        parent.add = {
+            type: "ModifierFlags",
+            parent,
+            start,
+            end,
+            raw: this.source.slice(start, end),
+            ignoreCase,
+            multiline,
+            dotAll,
+        }
+    }
+
+    public onRemoveModifiers(
+        start: number,
+        end: number,
+        {
+            ignoreCase,
+            multiline,
+            dotAll,
+        }: { ignoreCase: boolean; multiline: boolean; dotAll: boolean },
+    ): void {
+        const parent = this._node
+        if (parent.type !== "Modifiers") {
+            throw new Error("UnknownError")
+        }
+        parent.remove = {
+            type: "ModifierFlags",
+            parent,
+            start,
+            end,
+            raw: this.source.slice(start, end),
+            ignoreCase,
+            multiline,
+            dotAll,
+        }
+    }
+
     public onCapturingGroupEnter(start: number, name: string | null): void {
         const parent = this._node
         if (parent.type !== "Alternative") {
@@ -281,7 +419,7 @@ class RegExpParserState {
     public onEdgeAssertion(
         start: number,
         end: number,
-        kind: "start" | "end",
+        kind: "end" | "start",
     ): void {
         const parent = this._node
         if (parent.type !== "Alternative") {
@@ -347,7 +485,7 @@ class RegExpParserState {
             throw new Error("UnknownError")
         }
 
-        ;(parent.elements as CharacterClassElement[]).push({
+        parent.elements.push({
             type: "CharacterSet",
             parent,
             start,
@@ -365,32 +503,50 @@ class RegExpParserState {
         key: string,
         value: string | null,
         negate: boolean,
+        strings: boolean,
     ): void {
         const parent = this._node
         if (parent.type !== "Alternative" && parent.type !== "CharacterClass") {
             throw new Error("UnknownError")
         }
 
-        ;(parent.elements as CharacterClassElement[]).push({
+        const base = {
             type: "CharacterSet",
-            parent,
+            parent: null,
             start,
             end,
             raw: this.source.slice(start, end),
             kind,
+            strings: null,
             key,
-            value,
-            negate,
-        })
+        } as const
+
+        if (strings) {
+            if (
+                (parent.type === "CharacterClass" && !parent.unicodeSets) ||
+                negate ||
+                value !== null
+            ) {
+                throw new Error("UnknownError")
+            }
+
+            parent.elements.push({ ...base, parent, strings, value, negate })
+        } else {
+            parent.elements.push({ ...base, parent, strings, value, negate })
+        }
     }
 
     public onCharacter(start: number, end: number, value: number): void {
         const parent = this._node
-        if (parent.type !== "Alternative" && parent.type !== "CharacterClass") {
+        if (
+            parent.type !== "Alternative" &&
+            parent.type !== "CharacterClass" &&
+            parent.type !== "StringAlternative"
+        ) {
             throw new Error("UnknownError")
         }
 
-        ;(parent.elements as CharacterClassElement[]).push({
+        parent.elements.push({
             type: "Character",
             parent,
             start,
@@ -417,42 +573,92 @@ class RegExpParserState {
             end,
             raw: this.source.slice(start, end),
             ref,
-            resolved: DummyCapturingGroup,
+            ambiguous: false,
+            resolved: DUMMY_CAPTURING_GROUP,
         }
         parent.elements.push(node)
         this._backreferences.push(node)
     }
 
-    public onCharacterClassEnter(start: number, negate: boolean): void {
+    public onCharacterClassEnter(
+        start: number,
+        negate: boolean,
+        unicodeSets: boolean,
+    ): void {
         const parent = this._node
-        if (parent.type !== "Alternative") {
-            throw new Error("UnknownError")
-        }
-
-        this._node = {
-            type: "CharacterClass",
+        const base = {
+            type: "CharacterClass" as const,
             parent,
             start,
             end: start,
             raw: "",
+            unicodeSets,
             negate,
             elements: [],
         }
-        parent.elements.push(this._node)
+        if (parent.type === "Alternative") {
+            const node: CharacterClass = {
+                ...base,
+                parent,
+            }
+            this._node = node
+            parent.elements.push(node)
+        } else if (
+            parent.type === "CharacterClass" &&
+            parent.unicodeSets &&
+            unicodeSets
+        ) {
+            const node: UnicodeSetsCharacterClass = {
+                ...base,
+                parent,
+                unicodeSets,
+            }
+            this._node = node
+            parent.elements.push(node)
+        } else {
+            throw new Error("UnknownError")
+        }
     }
 
     public onCharacterClassLeave(start: number, end: number): void {
         const node = this._node
         if (
             node.type !== "CharacterClass" ||
-            node.parent.type !== "Alternative"
+            (node.parent.type !== "Alternative" &&
+                node.parent.type !== "CharacterClass")
         ) {
             throw new Error("UnknownError")
         }
+        const parent = node.parent
 
         node.end = end
         node.raw = this.source.slice(start, end)
-        this._node = node.parent
+        this._node = parent
+
+        const expression = this._expressionBufferMap.get(node)
+        if (!expression) {
+            return
+        }
+        if (node.elements.length > 0) {
+            throw new Error("UnknownError")
+        }
+        this._expressionBufferMap.delete(node)
+
+        // Replace with ExpressionCharacterClass.
+        const newNode: ExpressionCharacterClass = {
+            type: "ExpressionCharacterClass",
+            parent,
+            start: node.start,
+            end: node.end,
+            raw: node.raw,
+            negate: node.negate,
+            expression,
+        }
+        expression.parent = newNode
+        if (node !== parent.elements.pop()) {
+            throw new Error("UnknownError")
+        }
+        parent.elements.push(newNode)
     }
 
     public onCharacterClassRange(start: number, end: number): void {
@@ -464,17 +670,21 @@ class RegExpParserState {
         // Replace the last three elements.
         const elements = parent.elements
         const max = elements.pop()
-        const hyphen = elements.pop()
+        if (!max || max.type !== "Character") {
+            throw new Error("UnknownError")
+        }
+        if (!parent.unicodeSets) {
+            const hyphen = elements.pop()
+            if (
+                !hyphen ||
+                hyphen.type !== "Character" ||
+                hyphen.value !== HYPHEN_MINUS
+            ) {
+                throw new Error("UnknownError")
+            }
+        }
         const min = elements.pop()
-        if (
-            !min ||
-            !max ||
-            !hyphen ||
-            min.type !== "Character" ||
-            max.type !== "Character" ||
-            hyphen.type !== "Character" ||
-            hyphen.value !== HyphenMinus
-        ) {
+        if (!min || min.type !== "Character") {
             throw new Error("UnknownError")
         }
 
@@ -491,6 +701,133 @@ class RegExpParserState {
         max.parent = node
         elements.push(node)
     }
+
+    public onClassIntersection(start: number, end: number): void {
+        const parent = this._node
+        if (parent.type !== "CharacterClass" || !parent.unicodeSets) {
+            throw new Error("UnknownError")
+        }
+        // Replace the last two elements.
+        const right = parent.elements.pop()
+        const left =
+            this._expressionBufferMap.get(parent) ?? parent.elements.pop()
+        if (
+            !left ||
+            !right ||
+            left.type === "ClassSubtraction" ||
+            (left.type !== "ClassIntersection" && !isClassSetOperand(left)) ||
+            !isClassSetOperand(right)
+        ) {
+            throw new Error("UnknownError")
+        }
+        const node: ClassIntersection = {
+            type: "ClassIntersection",
+            parent:
+                // Temporarily cast. We will actually replace it later in `onCharacterClassLeave`.
+                parent as never as ExpressionCharacterClass,
+            start,
+            end,
+            raw: this.source.slice(start, end),
+            left,
+            right,
+        }
+        left.parent = node
+        right.parent = node
+        this._expressionBufferMap.set(parent, node)
+    }
+
+    public onClassSubtraction(start: number, end: number): void {
+        const parent = this._node
+        if (parent.type !== "CharacterClass" || !parent.unicodeSets) {
+            throw new Error("UnknownError")
+        }
+        // Replace the last two elements.
+        const right = parent.elements.pop()
+        const left =
+            this._expressionBufferMap.get(parent) ?? parent.elements.pop()
+        if (
+            !left ||
+            !right ||
+            left.type === "ClassIntersection" ||
+            (left.type !== "ClassSubtraction" && !isClassSetOperand(left)) ||
+            !isClassSetOperand(right)
+        ) {
+            throw new Error("UnknownError")
+        }
+        const node: ClassSubtraction = {
+            type: "ClassSubtraction",
+            parent:
+                // Temporarily cast. We will actually replace it later in `onCharacterClassLeave`.
+                parent as never as ExpressionCharacterClass,
+            start,
+            end,
+            raw: this.source.slice(start, end),
+            left,
+            right,
+        }
+        left.parent = node
+        right.parent = node
+        this._expressionBufferMap.set(parent, node)
+    }
+
+    public onClassStringDisjunctionEnter(start: number): void {
+        const parent = this._node
+        if (parent.type !== "CharacterClass" || !parent.unicodeSets) {
+            throw new Error("UnknownError")
+        }
+
+        this._node = {
+            type: "ClassStringDisjunction",
+            parent,
+            start,
+            end: start,
+            raw: "",
+            alternatives: [],
+        }
+        parent.elements.push(this._node)
+    }
+
+    public onClassStringDisjunctionLeave(start: number, end: number): void {
+        const node = this._node
+        if (
+            node.type !== "ClassStringDisjunction" ||
+            node.parent.type !== "CharacterClass"
+        ) {
+            throw new Error("UnknownError")
+        }
+
+        node.end = end
+        node.raw = this.source.slice(start, end)
+        this._node = node.parent
+    }
+
+    public onStringAlternativeEnter(start: number): void {
+        const parent = this._node
+        if (parent.type !== "ClassStringDisjunction") {
+            throw new Error("UnknownError")
+        }
+
+        this._node = {
+            type: "StringAlternative",
+            parent,
+            start,
+            end: start,
+            raw: "",
+            elements: [],
+        }
+        parent.alternatives.push(this._node)
+    }
+
+    public onStringAlternativeLeave(start: number, end: number): void {
+        const node = this._node
+        if (node.type !== "StringAlternative") {
+            throw new Error("UnknownError")
+        }
+
+        node.end = end
+        node.raw = this.source.slice(start, end)
+        this._node = node.parent
+    }
 }
 
 export namespace RegExpParser {
@@ -504,12 +841,15 @@ export namespace RegExpParser {
         strict?: boolean
 
         /**
-         * ECMAScript version. Default is `2022`.
+         * ECMAScript version. Default is `2025`.
          * - `2015` added `u` and `y` flags.
          * - `2018` added `s` flag, Named Capturing Group, Lookbehind Assertion,
          *   and Unicode Property Escape.
          * - `2019`, `2020`, and `2021` added more valid Unicode Property Escapes.
          * - `2022` added `d` flag.
+         * - `2023` added more valid Unicode Property Escapes.
+         * - `2024` added `v` flag.
+         * - `2025` added duplicate named capturing groups, modifiers.
          */
         ecmaVersion?: EcmaVersion
     }
@@ -517,6 +857,7 @@ export namespace RegExpParser {
 
 export class RegExpParser {
     private _state: RegExpParserState
+
     private _validator: RegExpValidator
 
     /**
@@ -580,17 +921,53 @@ export class RegExpParser {
      * @param source The source code to parse.
      * @param start The start index in the source code.
      * @param end The end index in the source code.
+     * @param flags The flags.
+     * @returns The AST of the given pattern.
+     */
+    public parsePattern(
+        source: string,
+        start?: number,
+        end?: number,
+        flags?: {
+            unicode?: boolean
+            unicodeSets?: boolean
+        },
+    ): Pattern
+    /**
+     * @deprecated Backward compatibility
+     * Use object `flags` instead of boolean `uFlag`.
+     *
+     * @param source The source code to parse.
+     * @param start The start index in the source code.
+     * @param end The end index in the source code.
      * @param uFlag The flag to set unicode mode.
      * @returns The AST of the given pattern.
      */
+    public parsePattern(
+        source: string,
+        start?: number,
+        end?: number,
+        uFlag?: boolean, // The unicode flag (backward compatibility).
+    ): Pattern
     public parsePattern(
         source: string,
         start = 0,
         end: number = source.length,
-        uFlag = false,
+        uFlagOrFlags:
+            | boolean
+            | {
+                  unicode?: boolean
+                  unicodeSets?: boolean
+              }
+            | undefined = undefined,
     ): Pattern {
         this._state.source = source
-        this._validator.validatePattern(source, start, end, uFlag)
+        this._validator.validatePattern(
+            source,
+            start,
+            end,
+            uFlagOrFlags as never,
+        )
         return this._state.pattern
     }
 }
diff --git a/src/reader.ts b/src/reader.ts
index deed1e8..e087616 100644
--- a/src/reader.ts
+++ b/src/reader.ts
@@ -17,16 +17,26 @@ const unicodeImpl = {
 
 export class Reader {
     private _impl = legacyImpl
+
     private _s = ""
+
     private _i = 0
+
     private _end = 0
-    private _cp1: number = -1
+
+    private _cp1 = -1
+
     private _w1 = 1
-    private _cp2: number = -1
+
+    private _cp2 = -1
+
     private _w2 = 1
-    private _cp3: number = -1
+
+    private _cp3 = -1
+
     private _w3 = 1
-    private _cp4: number = -1
+
+    private _cp4 = -1
 
     public get source(): string {
         return this._s
diff --git a/src/regexp-syntax-error.ts b/src/regexp-syntax-error.ts
index 2e7b88e..19a707c 100644
--- a/src/regexp-syntax-error.ts
+++ b/src/regexp-syntax-error.ts
@@ -1,21 +1,36 @@
+import type { RegExpValidatorSourceContext } from "./validator"
+
 export class RegExpSyntaxError extends SyntaxError {
     public index: number
-    public constructor(
-        source: string,
-        uFlag: boolean,
-        index: number,
-        message: string,
-    ) {
-        /*eslint-disable no-param-reassign */
-        if (source) {
-            if (!source.startsWith("/")) {
-                source = `/${source}/${uFlag ? "u" : ""}`
-            }
-            source = `: ${source}`
-        }
-        /*eslint-enable no-param-reassign */
 
-        super(`Invalid regular expression${source}: ${message}`)
+    public constructor(message: string, index: number) {
+        super(message)
         this.index = index
     }
 }
+
+export function newRegExpSyntaxError(
+    srcCtx: RegExpValidatorSourceContext,
+    flags: { unicode: boolean; unicodeSets: boolean },
+    index: number,
+    message: string,
+): RegExpSyntaxError {
+    let source = ""
+    if (srcCtx.kind === "literal") {
+        const literal = srcCtx.source.slice(srcCtx.start, srcCtx.end)
+        if (literal) {
+            source = `: ${literal}`
+        }
+    } else if (srcCtx.kind === "pattern") {
+        const pattern = srcCtx.source.slice(srcCtx.start, srcCtx.end)
+        const flagsText = `${flags.unicode ? "u" : ""}${
+            flags.unicodeSets ? "v" : ""
+        }`
+        source = `: /${pattern}/${flagsText}`
+    }
+
+    return new RegExpSyntaxError(
+        `Invalid regular expression${source}: ${message}`,
+        index,
+    )
+}
diff --git a/src/unicode/ids.ts b/src/unicode/ids.ts
index fae967d..67f969b 100644
--- a/src/unicode/ids.ts
+++ b/src/unicode/ids.ts
@@ -1,4 +1,4 @@
-/* Generated from DerivedCoreProperties-13.0.0.txt */
+/* Generated from DerivedCoreProperties-16.0.0.txt */
 
 // Each two-element represents a range.
 // Even indices are minimum values and odd indices are maximum values.
@@ -27,27 +27,27 @@ export function isIdContinue(cp: number): boolean {
 function isLargeIdStart(cp: number): boolean {
     return isInRange(
         cp,
-        largeIdStartRanges || (largeIdStartRanges = initLargeIdStartRanges()),
+        largeIdStartRanges ?? (largeIdStartRanges = initLargeIdStartRanges()),
     )
 }
 
 function isLargeIdContinue(cp: number): boolean {
     return isInRange(
         cp,
-        largeIdContinueRanges ||
+        largeIdContinueRanges ??
             (largeIdContinueRanges = initLargeIdContinueRanges()),
     )
 }
 
 function initLargeIdStartRanges(): number[] {
     return restoreRanges(
-        "4q 0 b 0 5 0 6 m 2 u 2 cp 5 b f 4 8 0 2 0 3m 4 2 1 3 3 2 0 7 0 2 2 2 0 2 j 2 2a 2 3u 9 4l 2 11 3 0 7 14 20 q 5 3 1a 16 10 1 2 2q 2 0 g 1 8 1 b 2 3 0 h 0 2 t u 2g c 0 p w a 1 5 0 6 l 5 0 a 0 4 0 o o 8 a 1i k 2 h 1p 1h 4 0 j 0 8 9 g f 5 7 3 1 3 l 2 6 2 0 4 3 4 0 h 0 e 1 2 2 f 1 b 0 9 5 5 1 3 l 2 6 2 1 2 1 2 1 w 3 2 0 k 2 h 8 2 2 2 l 2 6 2 1 2 4 4 0 j 0 g 1 o 0 c 7 3 1 3 l 2 6 2 1 2 4 4 0 v 1 2 2 g 0 i 0 2 5 4 2 2 3 4 1 2 0 2 1 4 1 4 2 4 b n 0 1h 7 2 2 2 m 2 f 4 0 r 2 6 1 v 0 5 7 2 2 2 m 2 9 2 4 4 0 x 0 2 1 g 1 i 8 2 2 2 14 3 0 h 0 6 2 9 2 p 5 6 h 4 n 2 8 2 0 3 6 1n 1b 2 1 d 6 1n 1 2 0 2 4 2 n 2 0 2 9 2 1 a 0 3 4 2 0 m 3 x 0 1s 7 2 z s 4 38 16 l 0 h 5 5 3 4 0 4 1 8 2 5 c d 0 i 11 2 0 6 0 3 16 2 98 2 3 3 6 2 0 2 3 3 14 2 3 3 w 2 3 3 6 2 0 2 3 3 e 2 1k 2 3 3 1u 12 f h 2d 3 5 4 h7 3 g 2 p 6 22 4 a 8 c 2 3 f h f h f c 2 2 g 1f 10 0 5 0 1w 2g 8 14 2 0 6 1x b u 1e t 3 4 c 17 5 p 1j m a 1g 2b 0 2m 1a i 6 1k t e 1 b 17 r z 16 2 b z 3 8 8 16 3 2 16 3 2 5 2 1 4 0 6 5b 1t 7p 3 5 3 11 3 5 3 7 2 0 2 0 2 0 2 u 3 1g 2 6 2 0 4 2 2 6 4 3 3 5 5 c 6 2 2 6 39 0 e 0 h c 2u 0 5 0 3 9 2 0 3 5 7 0 2 0 2 0 2 f 3 3 6 4 5 0 i 14 22g 1a 2 1a 2 3o 7 3 4 1 d 11 2 0 6 0 3 1j 8 0 h m a 6 2 6 2 6 2 6 2 6 2 6 2 6 2 6 fb 2 q 8 8 4 3 4 5 2d 5 4 2 2h 2 3 6 16 2 2l i v 1d f e9 533 1t g70 4 wc 1w 19 3 7g 4 f b 1 l 1a h u 3 27 14 8 3 2u 3 1g 3 8 17 c 2 2 2 3 2 m u 1f f 1d 1r 5 4 0 2 1 c r b m q s 8 1a t 0 h 4 2 9 b 4 2 14 o 2 2 7 l m 4 0 4 1d 2 0 4 1 3 4 3 0 2 0 p 2 3 a 8 2 d 5 3 5 3 5 a 6 2 6 2 16 2 d 7 36 u 8mb d m 5 1c 6it a5 3 2x 13 6 d 4 6 0 2 9 2 c 2 4 2 0 2 1 2 1 2 2z y a2 j 1r 3 1h 15 b 39 4 2 3q 11 p 7 p c 2g 4 5 3 5 3 5 3 2 10 b 2 p 2 i 2 1 2 e 3 d z 3e 1y 1g 7g s 4 1c 1c v e t 6 11 b t 3 z 5 7 2 4 17 4d j z 5 z 5 13 9 1f 4d 8m a l b 7 49 5 3 0 2 17 2 1 4 0 3 m b m a u 1u i 2 1 b l b p 1z 1j 7 1 1t 0 g 3 2 2 2 s 17 s 4 s 10 7 2 r s 1h b l b i e h 33 20 1k 1e e 1e e z 9p 15 7 1 27 s b 0 9 l 2z k s m d 1g 24 18 x o r z u 0 3 0 9 y 4 0 d 1b f 3 m 0 2 0 10 h 2 o 2d 6 2 0 2 3 2 e 2 9 8 1a 13 7 3 1 3 l 2 6 2 1 2 4 4 0 j 0 d 4 4f 1g j 3 l 2 v 1b l 1 2 0 55 1a 16 3 11 1b l 0 1o 16 e 0 20 q 6e 17 39 1r w 7 3 0 3 7 2 1 2 n g 0 2 0 2n 7 3 12 h 0 2 0 t 0 b 13 8 0 m 0 c 19 k 0 z 1k 7c 8 2 10 i 0 1e t 35 6 2 1 2 11 m 0 q 5 2 1 2 v f 0 94 i 5a 0 28 pl 2v 32 i 5f 24d tq 34i g6 6nu fs 8 u 36 t j 1b h 3 w k 6 i j5 1r 3l 22 6 0 1v c 1t 1 2 0 t 4qf 9 yd 17 8 6wo 7y 1e 2 i 3 9 az 1s5 2y 6 c 4 8 8 9 4mf 2c 2 1y 2 1 3 0 3 1 3 3 2 b 2 0 2 6 2 1s 2 3 3 7 2 6 2 r 2 3 2 4 2 0 4 6 2 9f 3 o 2 o 2 u 2 o 2 u 2 o 2 u 2 o 2 u 2 o 2 7 1th 18 b 6 h 0 aa 17 105 5g 1o 1v 8 0 xh 3 2 q 2 1 2 0 3 0 2 9 2 3 2 0 2 0 7 0 5 0 2 0 2 0 2 2 2 1 2 0 3 0 2 0 2 0 2 0 2 0 2 1 2 0 3 3 2 6 2 3 2 3 2 0 2 9 2 g 6 2 2 4 2 g 3et wyl z 378 c 65 3 4g1 f 5rk 2e8 f1 15v 3t6",
+        "4q 0 b 0 5 0 6 m 2 u 2 cp 5 b f 4 8 0 2 0 3m 4 2 1 3 3 2 0 7 0 2 2 2 0 2 j 2 2a 2 3u 9 4l 2 11 3 0 7 14 20 q 5 3 1a 16 10 1 2 2q 2 0 g 1 8 1 b 2 3 0 h 0 2 t u 2g c 0 p w a 1 5 0 6 l 5 0 a 0 4 0 o o 8 a 6 n 2 5 i 15 1n 1h 4 0 j 0 8 9 g f 5 7 3 1 3 l 2 6 2 0 4 3 4 0 h 0 e 1 2 2 f 1 b 0 9 5 5 1 3 l 2 6 2 1 2 1 2 1 w 3 2 0 k 2 h 8 2 2 2 l 2 6 2 1 2 4 4 0 j 0 g 1 o 0 c 7 3 1 3 l 2 6 2 1 2 4 4 0 v 1 2 2 g 0 i 0 2 5 4 2 2 3 4 1 2 0 2 1 4 1 4 2 4 b n 0 1h 7 2 2 2 m 2 f 4 0 r 2 3 0 3 1 v 0 5 7 2 2 2 m 2 9 2 4 4 0 w 1 2 1 g 1 i 8 2 2 2 14 3 0 h 0 6 2 9 2 p 5 6 h 4 n 2 8 2 0 3 6 1n 1b 2 1 d 6 1n 1 2 0 2 4 2 n 2 0 2 9 2 1 a 0 3 4 2 0 m 3 x 0 1s 7 2 z s 4 38 16 l 0 h 5 5 3 4 0 4 1 8 2 5 c d 0 i 11 2 0 6 0 3 16 2 98 2 3 3 6 2 0 2 3 3 14 2 3 3 w 2 3 3 6 2 0 2 3 3 e 2 1k 2 3 3 1u 12 f h 2d 3 5 4 h7 3 g 2 p 6 22 4 a 8 h e i f h f c 2 2 g 1f 10 0 5 0 1w 2g 8 14 2 0 6 1x b u 1e t 3 4 c 17 5 p 1j m a 1g 2b 0 2m 1a i 7 1j t e 1 b 17 r z 16 2 b z 3 a 6 16 3 2 16 3 2 5 2 1 4 0 6 5b 1t 7p 3 5 3 11 3 5 3 7 2 0 2 0 2 0 2 u 3 1g 2 6 2 0 4 2 2 6 4 3 3 5 5 c 6 2 2 6 39 0 e 0 h c 2u 0 5 0 3 9 2 0 3 5 7 0 2 0 2 0 2 f 3 3 6 4 5 0 i 14 22g 6c 7 3 4 1 d 11 2 0 6 0 3 1j 8 0 h m a 6 2 6 2 6 2 6 2 6 2 6 2 6 2 6 fb 2 q 8 8 4 3 4 5 2d 5 4 2 2h 2 3 6 16 2 2l i v 1d f e9 533 1t h3g 1w 19 3 7g 4 f b 1 l 1a h u 3 27 14 8 3 2u 3 1u 3 1 2 0 2 7 m f 2 2 2 3 2 m u 1f f 1d 1r 5 4 0 2 1 c r b m q s 8 1a t 0 h 4 2 9 b 4 2 14 o 2 2 7 l m 4 0 4 1d 2 0 4 1 3 4 3 0 2 0 p 2 3 a 8 2 d 5 3 5 3 5 a 6 2 6 2 16 2 d 7 36 u 8mb d m 5 1c 6it a5 3 2x 13 6 d 4 6 0 2 9 2 c 2 4 2 0 2 1 2 1 2 2z y a2 j 1r 3 1h 15 b 39 4 2 3q 11 p 7 p c 2g 4 5 3 5 3 5 3 2 10 b 2 p 2 i 2 1 2 e 3 d z 3e 1y 1g 7g s 4 1c 1c v e t 6 11 b t 3 z 5 7 2 4 17 4d j z 5 z 5 13 9 1f d a 2 e 2 6 2 1 2 a 2 e 2 6 2 1 4 1f d 8m a l b 7 p 5 2 15 2 8 1y 5 3 0 2 17 2 1 4 0 3 m b m a u 1u i 2 1 b l b p 1z 1j 7 1 1t 0 g 3 2 2 2 s 17 s 4 s 10 7 2 r s 1h b l b i e h 33 20 1k 1e e 1e e z 13 r a m 6z 15 7 1 h 2 1o s b 0 9 l 17 h 1b k s m d 1g 1m 1 3 0 e 18 x o r z u 0 3 0 9 y 4 0 d 1b f 3 m 0 2 0 10 h 2 o k 1 1s 6 2 0 2 3 2 e 2 9 8 1a 13 7 3 1 3 l 2 6 2 1 2 4 4 0 j 0 d 4 v 9 2 0 3 0 2 11 2 0 q 0 2 0 19 1g j 3 l 2 v 1b l 1 2 0 55 1a 16 3 11 1b l 0 1o 16 e 0 20 q 12 6 56 17 39 1r w 7 3 0 3 7 2 1 2 n g 0 2 0 2n 7 3 12 h 0 2 0 t 0 b 13 8 0 m 0 c 19 k 0 j 20 5k w w 8 2 10 i 0 1e t 35 6 2 1 2 11 m 0 q 5 2 1 2 v f 0 94 i g 0 2 c 2 x 3h 0 28 pl 2v 32 i 5f 219 2o g tr i 5 q 32y 6 g6 5a2 t 1cz fs 8 u i 26 i t j 1b h 3 w k 6 i c1 18 5w 1r 3l 22 6 0 1v c 1t 1 2 0 t 4qf 9 yd 16 9 6w8 3 2 6 2 1 2 82 g 0 u 2 3 0 f 3 9 az 1s5 2y 6 c 4 8 8 9 4mf 2c 2 1y 2 1 3 0 3 1 3 3 2 b 2 0 2 6 2 1s 2 3 3 7 2 6 2 r 2 3 2 4 2 0 4 6 2 9f 3 o 2 o 2 u 2 o 2 u 2 o 2 u 2 o 2 u 2 o 2 7 1f9 u 7 5 7a 1p 43 18 b 6 h 0 8y t j 17 dh r 6d t 3 0 ds 6 2 3 2 1 2 e 2 5g 1o 1v 8 0 xh 3 2 q 2 1 2 0 3 0 2 9 2 3 2 0 2 0 7 0 5 0 2 0 2 0 2 2 2 1 2 0 3 0 2 0 2 0 2 0 2 0 2 1 2 0 3 3 2 6 2 3 2 3 2 0 2 9 2 g 6 2 2 4 2 g 3et wyn x 37d 7 65 3 4g1 f 5rk g h9 1wj f1 15v 3t6 6 38f",
     )
 }
 
 function initLargeIdContinueRanges(): number[] {
     return restoreRanges(
-        "53 0 g9 33 o 0 70 4 7e 18 2 0 2 1 2 1 2 0 21 a 1d u 7 0 2u 6 3 5 3 1 2 3 3 9 o 0 v q 2k a g 9 y 8 a 0 p 3 2 8 2 2 2 4 18 2 3c e 2 w 1j 2 2 h 2 6 b 1 3 9 i 2 1l 0 2 6 3 1 3 2 a 0 b 1 3 9 f 0 3 2 1l 0 2 4 5 1 3 2 4 0 l b 4 0 c 2 1l 0 2 7 2 2 2 2 l 1 3 9 b 5 2 2 1l 0 2 6 3 1 3 2 8 2 b 1 3 9 j 0 1o 4 4 2 2 3 a 0 f 9 h 4 1m 6 2 2 2 3 8 1 c 1 3 9 i 2 1l 0 2 6 2 2 2 3 8 1 c 1 3 9 h 3 1k 1 2 6 2 2 2 3 a 0 b 1 3 9 i 2 1z 0 5 5 2 0 2 7 7 9 3 1 1q 0 3 6 d 7 2 9 2g 0 3 8 c 5 3 9 1r 1 7 9 c 0 2 0 2 0 5 1 1e j 2 1 6 a 2 z a 0 2t j 2 9 d 3 5 2 2 2 3 6 4 3 e b 2 e jk 2 a 8 pt 2 u 2 u 1 v 1 1t v a 0 3 9 y 2 3 9 40 0 3b b 5 b b 9 3l a 1p 4 1m 9 2 s 3 a 7 9 n d 2 1 1s 4 1c g c 9 i 8 d 2 v c 3 9 19 d 1d j 9 9 7 9 3b 2 2 k 5 0 7 0 3 2 5j 1l 2 4 g0 1 k 0 3g c 5 0 4 b 2db 2 3y 0 2p v ff 5 2y 1 n7q 9 1y 0 5 9 x 1 29 1 7l 0 4 0 5 0 o 4 5 0 2c 1 1f h b 9 7 h e a t 7 q c 19 3 1c d g 9 c 0 b 9 1c d d 0 9 1 3 9 y 2 1f 0 2 2 3 1 6 1 2 0 16 4 6 1 6l 7 2 1 3 9 fmt 0 ki f h f 4 1 p 2 5d 9 12 0 ji 0 6b 0 46 4 86 9 120 2 2 1 6 3 15 2 5 0 4m 1 fy 3 9 9 aa 1 4a a 4w 2 1i e w 9 g 3 1a a 1i 9 7 2 11 d 2 9 6 1 19 0 d 2 1d d 9 3 2 b 2b b 7 0 4h b 6 9 7 3 1k 1 2 6 3 1 3 2 a 0 b 1 3 6 4 4 5d h a 9 5 0 2a j d 9 5y 6 3 8 s 1 2b g g 9 2a c 9 9 2c e 5 9 6r e 4m 9 1z 5 2 1 3 3 2 0 2 1 d 9 3c 6 3 6 4 0 t 9 15 6 2 3 9 0 a a 1b f ba 7 2 7 h 9 1l l 2 d 3f 5 4 0 2 1 2 6 2 0 9 9 1d 4 2 1 2 4 9 9 96 3 ewa 9 3r 4 1o 6 q 9 s6 0 2 1i 8 3 2a 0 c 1 f58 1 43r 4 4 5 9 7 3 6 v 3 45 2 13e 1d e9 1i 5 1d 9 0 f 0 n 4 2 e 11t 6 2 g 3 6 2 1 2 4 7a 6 a 9 bn d 15j 6 32 6 6 9 3o7 9 gvt3 6n",
+        "53 0 g9 33 o 0 70 4 7e 18 2 0 2 1 2 1 2 0 21 a 1d u 7 0 2u 6 3 5 3 1 2 3 3 9 o 0 v q 2k a g 9 y 8 a 0 p 3 2 8 2 2 2 4 18 2 1o 8 17 n 2 w 1j 2 2 h 2 6 b 1 3 9 i 2 1l 0 2 6 3 1 3 2 a 0 b 1 3 9 f 0 3 2 1l 0 2 4 5 1 3 2 4 0 l b 4 0 c 2 1l 0 2 7 2 2 2 2 l 1 3 9 b 5 2 2 1l 0 2 6 3 1 3 2 8 2 b 1 3 9 j 0 1o 4 4 2 2 3 a 0 f 9 h 4 1k 0 2 6 2 2 2 3 8 1 c 1 3 9 i 2 1l 0 2 6 2 2 2 3 8 1 c 1 3 9 4 0 d 3 1k 1 2 6 2 2 2 3 a 0 b 1 3 9 i 2 1z 0 5 5 2 0 2 7 7 9 3 1 1q 0 3 6 d 7 2 9 2g 0 3 8 c 6 2 9 1r 1 7 9 c 0 2 0 2 0 5 1 1e j 2 1 6 a 2 z a 0 2t j 2 9 d 3 5 2 2 2 3 6 4 3 e b 2 e jk 2 a 8 pt 3 t 2 u 1 v 1 1t v a 0 3 9 y 2 2 a 40 0 3b b 5 b b 9 3l a 1p 4 1m 9 2 s 3 a 7 9 n d 2 f 1e 4 1c g c 9 i 8 d 2 v c 3 9 19 d 1d j 9 9 7 9 3b 2 2 k 5 0 7 0 3 2 5j 1r el 1 1e 1 k 0 3g c 5 0 4 b 2db 2 3y 0 2p v ff 5 2y 1 2p 0 n51 9 1y 0 5 9 x 1 29 1 7l 0 4 0 5 0 o 4 5 0 2c 1 1f h b 9 7 h e a t 7 q c 19 3 1c d g 9 c 0 b 9 1c d d 0 9 1 3 9 y 2 1f 0 2 2 3 1 6 1 2 0 16 4 6 1 6l 7 2 1 3 9 fmt 0 ki f h f 4 1 p 2 5d 9 12 0 12 0 ig 0 6b 0 46 4 86 9 120 2 2 1 6 3 15 2 5 0 4m 1 fy 3 9 9 7 9 w 4 8u 1 28 3 1z a 1e 3 3f 2 1i e w a 3 1 b 3 1a a 8 0 1a 9 7 2 11 d 2 9 6 1 19 0 d 2 1d d 9 3 2 b 2b b 7 0 3 0 4e b 6 9 7 3 1k 1 2 6 3 1 3 2 a 0 b 1 3 6 4 4 1w 8 2 0 3 0 2 3 2 4 2 0 f 1 2b h a 9 5 0 2a j d 9 5y 6 3 8 s 1 2b g g 9 2a c 9 9 7 j 1m e 5 9 6r e 4m 9 1z 5 2 1 3 3 2 0 2 1 d 9 3c 6 3 6 4 0 t 9 15 6 2 3 9 0 a a 1b f 9j 9 1i 7 2 7 h 9 1l l 2 d 3f 5 4 0 2 1 2 6 2 0 9 9 1d 4 2 1 2 4 9 9 96 3 a 1 2 0 1d 6 4 4 e a 44m 0 7 e 8uh r 1t3 9 2f 9 13 4 1o 6 q 9 ev 9 d2 0 2 1i 8 3 2a 0 c 1 f58 1 382 9 ef 19 3 m f3 4 4 5 9 7 3 6 v 3 45 2 13e 1d e9 1i 5 1d 9 0 f 0 n 4 2 e 11t 6 2 g 3 6 2 1 2 4 2t 0 4h 6 a 9 9x 0 1q d dv d 6t 1 2 9 k6 6 32 6 6 9 3o7 9 gvt3 6n",
     )
 }
 
@@ -74,5 +74,5 @@ function isInRange(cp: number, ranges: number[]): boolean {
 
 function restoreRanges(data: string): number[] {
     let last = 0
-    return data.split(" ").map(s => (last += parseInt(s, 36) | 0))
+    return data.split(" ").map((s) => (last += parseInt(s, 36) | 0))
 }
diff --git a/src/unicode/index.ts b/src/unicode/index.ts
index 8b59034..fb6e95b 100644
--- a/src/unicode/index.ts
+++ b/src/unicode/index.ts
@@ -2,122 +2,131 @@ export { isIdContinue, isIdStart } from "./ids"
 export {
     isValidLoneUnicodeProperty,
     isValidUnicodeProperty,
+    isValidLoneUnicodePropertyOfString,
 } from "./properties"
 
-export const Null = 0x00
-export const Backspace = 0x08
-export const CharacterTabulation = 0x09
-export const LineFeed = 0x0a
-export const LineTabulation = 0x0b
-export const FormFeed = 0x0c
-export const CarriageReturn = 0x0d
-export const ExclamationMark = 0x21
-export const DollarSign = 0x24
-export const LeftParenthesis = 0x28
-export const RightParenthesis = 0x29
-export const Asterisk = 0x2a
-export const PlusSign = 0x2b
-export const Comma = 0x2c
-export const HyphenMinus = 0x2d
-export const FullStop = 0x2e
-export const Solidus = 0x2f
-export const DigitZero = 0x30
-export const DigitOne = 0x31
-export const DigitSeven = 0x37
-export const DigitNine = 0x39
-export const Colon = 0x3a
-export const LessThanSign = 0x3c
-export const EqualsSign = 0x3d
-export const GreaterThanSign = 0x3e
-export const QuestionMark = 0x3f
-export const LatinCapitalLetterA = 0x41
-export const LatinCapitalLetterB = 0x42
-export const LatinCapitalLetterD = 0x44
-export const LatinCapitalLetterF = 0x46
-export const LatinCapitalLetterP = 0x50
-export const LatinCapitalLetterS = 0x53
-export const LatinCapitalLetterW = 0x57
-export const LatinCapitalLetterZ = 0x5a
-export const LowLine = 0x5f
-export const LatinSmallLetterA = 0x61
-export const LatinSmallLetterB = 0x62
-export const LatinSmallLetterC = 0x63
-export const LatinSmallLetterD = 0x64
-export const LatinSmallLetterF = 0x66
-export const LatinSmallLetterG = 0x67
-export const LatinSmallLetterI = 0x69
-export const LatinSmallLetterK = 0x6b
-export const LatinSmallLetterM = 0x6d
-export const LatinSmallLetterN = 0x6e
-export const LatinSmallLetterP = 0x70
-export const LatinSmallLetterR = 0x72
-export const LatinSmallLetterS = 0x73
-export const LatinSmallLetterT = 0x74
-export const LatinSmallLetterU = 0x75
-export const LatinSmallLetterV = 0x76
-export const LatinSmallLetterW = 0x77
-export const LatinSmallLetterX = 0x78
-export const LatinSmallLetterY = 0x79
-export const LatinSmallLetterZ = 0x7a
-export const LeftSquareBracket = 0x5b
-export const ReverseSolidus = 0x5c
-export const RightSquareBracket = 0x5d
-export const CircumflexAccent = 0x5e
-export const LeftCurlyBracket = 0x7b
-export const VerticalLine = 0x7c
-export const RightCurlyBracket = 0x7d
-export const ZeroWidthNonJoiner = 0x200c
-export const ZeroWidthJoiner = 0x200d
-export const LineSeparator = 0x2028
-export const ParagraphSeparator = 0x2029
+export const NULL = 0x00
+export const BACKSPACE = 0x08
+export const CHARACTER_TABULATION = 0x09
+export const LINE_FEED = 0x0a
+export const LINE_TABULATION = 0x0b
+export const FORM_FEED = 0x0c
+export const CARRIAGE_RETURN = 0x0d
+export const EXCLAMATION_MARK = 0x21
+export const NUMBER_SIGN = 0x23
+export const DOLLAR_SIGN = 0x24
+export const PERCENT_SIGN = 0x25
+export const AMPERSAND = 0x26
+export const LEFT_PARENTHESIS = 0x28
+export const RIGHT_PARENTHESIS = 0x29
+export const ASTERISK = 0x2a
+export const PLUS_SIGN = 0x2b
+export const COMMA = 0x2c
+export const HYPHEN_MINUS = 0x2d
+export const FULL_STOP = 0x2e
+export const SOLIDUS = 0x2f
+export const DIGIT_ZERO = 0x30
+export const DIGIT_ONE = 0x31
+export const DIGIT_SEVEN = 0x37
+export const DIGIT_NINE = 0x39
+export const COLON = 0x3a
+export const SEMICOLON = 0x3b
+export const LESS_THAN_SIGN = 0x3c
+export const EQUALS_SIGN = 0x3d
+export const GREATER_THAN_SIGN = 0x3e
+export const QUESTION_MARK = 0x3f
+export const COMMERCIAL_AT = 0x40
+export const LATIN_CAPITAL_LETTER_A = 0x41
+export const LATIN_CAPITAL_LETTER_B = 0x42
+export const LATIN_CAPITAL_LETTER_D = 0x44
+export const LATIN_CAPITAL_LETTER_F = 0x46
+export const LATIN_CAPITAL_LETTER_P = 0x50
+export const LATIN_CAPITAL_LETTER_S = 0x53
+export const LATIN_CAPITAL_LETTER_W = 0x57
+export const LATIN_CAPITAL_LETTER_Z = 0x5a
+export const LOW_LINE = 0x5f
+export const LATIN_SMALL_LETTER_A = 0x61
+export const LATIN_SMALL_LETTER_B = 0x62
+export const LATIN_SMALL_LETTER_C = 0x63
+export const LATIN_SMALL_LETTER_D = 0x64
+export const LATIN_SMALL_LETTER_F = 0x66
+export const LATIN_SMALL_LETTER_G = 0x67
+export const LATIN_SMALL_LETTER_I = 0x69
+export const LATIN_SMALL_LETTER_K = 0x6b
+export const LATIN_SMALL_LETTER_M = 0x6d
+export const LATIN_SMALL_LETTER_N = 0x6e
+export const LATIN_SMALL_LETTER_P = 0x70
+export const LATIN_SMALL_LETTER_Q = 0x71
+export const LATIN_SMALL_LETTER_R = 0x72
+export const LATIN_SMALL_LETTER_S = 0x73
+export const LATIN_SMALL_LETTER_T = 0x74
+export const LATIN_SMALL_LETTER_U = 0x75
+export const LATIN_SMALL_LETTER_V = 0x76
+export const LATIN_SMALL_LETTER_W = 0x77
+export const LATIN_SMALL_LETTER_X = 0x78
+export const LATIN_SMALL_LETTER_Y = 0x79
+export const LATIN_SMALL_LETTER_Z = 0x7a
+export const LEFT_SQUARE_BRACKET = 0x5b
+export const REVERSE_SOLIDUS = 0x5c
+export const RIGHT_SQUARE_BRACKET = 0x5d
+export const CIRCUMFLEX_ACCENT = 0x5e
+export const GRAVE_ACCENT = 0x60
+export const LEFT_CURLY_BRACKET = 0x7b
+export const VERTICAL_LINE = 0x7c
+export const RIGHT_CURLY_BRACKET = 0x7d
+export const TILDE = 0x7e
+export const ZERO_WIDTH_NON_JOINER = 0x200c
+export const ZERO_WIDTH_JOINER = 0x200d
+export const LINE_SEPARATOR = 0x2028
+export const PARAGRAPH_SEPARATOR = 0x2029
 
-export const MinCodePoint = 0x00
-export const MaxCodePoint = 0x10ffff
+export const MIN_CODE_POINT = 0x00
+export const MAX_CODE_POINT = 0x10ffff
 
 export function isLatinLetter(code: number): boolean {
     return (
-        (code >= LatinCapitalLetterA && code <= LatinCapitalLetterZ) ||
-        (code >= LatinSmallLetterA && code <= LatinSmallLetterZ)
+        (code >= LATIN_CAPITAL_LETTER_A && code <= LATIN_CAPITAL_LETTER_Z) ||
+        (code >= LATIN_SMALL_LETTER_A && code <= LATIN_SMALL_LETTER_Z)
     )
 }
 
 export function isDecimalDigit(code: number): boolean {
-    return code >= DigitZero && code <= DigitNine
+    return code >= DIGIT_ZERO && code <= DIGIT_NINE
 }
 
 export function isOctalDigit(code: number): boolean {
-    return code >= DigitZero && code <= DigitSeven
+    return code >= DIGIT_ZERO && code <= DIGIT_SEVEN
 }
 
 export function isHexDigit(code: number): boolean {
     return (
-        (code >= DigitZero && code <= DigitNine) ||
-        (code >= LatinCapitalLetterA && code <= LatinCapitalLetterF) ||
-        (code >= LatinSmallLetterA && code <= LatinSmallLetterF)
+        (code >= DIGIT_ZERO && code <= DIGIT_NINE) ||
+        (code >= LATIN_CAPITAL_LETTER_A && code <= LATIN_CAPITAL_LETTER_F) ||
+        (code >= LATIN_SMALL_LETTER_A && code <= LATIN_SMALL_LETTER_F)
     )
 }
 
 export function isLineTerminator(code: number): boolean {
     return (
-        code === LineFeed ||
-        code === CarriageReturn ||
-        code === LineSeparator ||
-        code === ParagraphSeparator
+        code === LINE_FEED ||
+        code === CARRIAGE_RETURN ||
+        code === LINE_SEPARATOR ||
+        code === PARAGRAPH_SEPARATOR
     )
 }
 
 export function isValidUnicode(code: number): boolean {
-    return code >= MinCodePoint && code <= MaxCodePoint
+    return code >= MIN_CODE_POINT && code <= MAX_CODE_POINT
 }
 
 export function digitToInt(code: number): number {
-    if (code >= LatinSmallLetterA && code <= LatinSmallLetterF) {
-        return code - LatinSmallLetterA + 10
+    if (code >= LATIN_SMALL_LETTER_A && code <= LATIN_SMALL_LETTER_F) {
+        return code - LATIN_SMALL_LETTER_A + 10
     }
-    if (code >= LatinCapitalLetterA && code <= LatinCapitalLetterF) {
-        return code - LatinCapitalLetterA + 10
+    if (code >= LATIN_CAPITAL_LETTER_A && code <= LATIN_CAPITAL_LETTER_F) {
+        return code - LATIN_CAPITAL_LETTER_A + 10
     }
-    return code - DigitZero
+    return code - DIGIT_ZERO
 }
 
 export function isLeadSurrogate(code: number): boolean {
diff --git a/src/unicode/properties.ts b/src/unicode/properties.ts
index 55b6601..ce98980 100644
--- a/src/unicode/properties.ts
+++ b/src/unicode/properties.ts
@@ -2,42 +2,114 @@
 
 class DataSet {
     private _raw2018: string
+
     private _set2018: Set<string> | undefined
+
     private _raw2019: string
+
     private _set2019: Set<string> | undefined
+
     private _raw2020: string
+
     private _set2020: Set<string> | undefined
+
     private _raw2021: string
+
     private _set2021: Set<string> | undefined
+
+    private _raw2022: string
+
+    private _set2022: Set<string> | undefined
+
+    private _raw2023: string
+
+    private _set2023: Set<string> | undefined
+
+    private _raw2024: string
+
+    private _set2024: Set<string> | undefined
+
+    private _raw2025: string
+
+    private _set2025: Set<string> | undefined
+
+    private _raw2026: string
+
+    private _set2026: Set<string> | undefined
+
     public constructor(
         raw2018: string,
         raw2019: string,
         raw2020: string,
         raw2021: string,
+        raw2022: string,
+        raw2023: string,
+        raw2024: string,
+        raw2025: string,
+        raw2026: string,
     ) {
         this._raw2018 = raw2018
         this._raw2019 = raw2019
         this._raw2020 = raw2020
         this._raw2021 = raw2021
+        this._raw2022 = raw2022
+        this._raw2023 = raw2023
+        this._raw2024 = raw2024
+        this._raw2025 = raw2025
+        this._raw2026 = raw2026
     }
+
     public get es2018(): Set<string> {
         return (
-            this._set2018 || (this._set2018 = new Set(this._raw2018.split(" ")))
+            this._set2018 ?? (this._set2018 = new Set(this._raw2018.split(" ")))
         )
     }
+
     public get es2019(): Set<string> {
         return (
-            this._set2019 || (this._set2019 = new Set(this._raw2019.split(" ")))
+            this._set2019 ?? (this._set2019 = new Set(this._raw2019.split(" ")))
         )
     }
+
     public get es2020(): Set<string> {
         return (
-            this._set2020 || (this._set2020 = new Set(this._raw2020.split(" ")))
+            this._set2020 ?? (this._set2020 = new Set(this._raw2020.split(" ")))
         )
     }
+
     public get es2021(): Set<string> {
         return (
-            this._set2021 || (this._set2021 = new Set(this._raw2021.split(" ")))
+            this._set2021 ?? (this._set2021 = new Set(this._raw2021.split(" ")))
+        )
+    }
+
+    public get es2022(): Set<string> {
+        return (
+            this._set2022 ?? (this._set2022 = new Set(this._raw2022.split(" ")))
+        )
+    }
+
+    public get es2023(): Set<string> {
+        return (
+            this._set2023 ?? (this._set2023 = new Set(this._raw2023.split(" ")))
+        )
+    }
+
+    public get es2024(): Set<string> {
+        return (
+            this._set2024 ?? (this._set2024 = new Set(this._raw2024.split(" ")))
+        )
+    }
+
+    public get es2025(): Set<string> {
+        return (
+            this._set2025 ?? (this._set2025 = new Set(this._raw2025.split(" ")))
+        )
+    }
+
+    public get es2026(): Set<string> {
+        return (
+            this._set2026 ?? (this._set2026 = new Set(this._raw2026.split(" ")))
         )
     }
 }
@@ -49,18 +121,44 @@ const gcValueSets = new DataSet(
     "",
     "",
     "",
+    "",
+    "",
+    "",
+    "",
+    "",
 )
 const scValueSets = new DataSet(
     "Adlam Adlm Aghb Ahom Anatolian_Hieroglyphs Arab Arabic Armenian Armi Armn Avestan Avst Bali Balinese Bamu Bamum Bass Bassa_Vah Batak Batk Beng Bengali Bhaiksuki Bhks Bopo Bopomofo Brah Brahmi Brai Braille Bugi Buginese Buhd Buhid Cakm Canadian_Aboriginal Cans Cari Carian Caucasian_Albanian Chakma Cham Cher Cherokee Common Copt Coptic Cprt Cuneiform Cypriot Cyrillic Cyrl Deseret Deva Devanagari Dsrt Dupl Duployan Egyp Egyptian_Hieroglyphs Elba Elbasan Ethi Ethiopic Geor Georgian Glag Glagolitic Gonm Goth Gothic Gran Grantha Greek Grek Gujarati Gujr Gurmukhi Guru Han Hang Hangul Hani Hano Hanunoo Hatr Hatran Hebr Hebrew Hira Hiragana Hluw Hmng Hung Imperial_Aramaic Inherited Inscriptional_Pahlavi Inscriptional_Parthian Ital Java Javanese Kaithi Kali Kana Kannada Katakana Kayah_Li Khar Kharoshthi Khmer Khmr Khoj Khojki Khudawadi Knda Kthi Lana Lao Laoo Latin Latn Lepc Lepcha Limb Limbu Lina Linb Linear_A Linear_B Lisu Lyci Lycian Lydi Lydian Mahajani Mahj Malayalam Mand Mandaic Mani Manichaean Marc Marchen Masaram_Gondi Meetei_Mayek Mend Mende_Kikakui Merc Mero Meroitic_Cursive Meroitic_Hieroglyphs Miao Mlym Modi Mong Mongolian Mro Mroo Mtei Mult Multani Myanmar Mymr Nabataean Narb Nbat New_Tai_Lue Newa Nko Nkoo Nshu Nushu Ogam Ogham Ol_Chiki Olck Old_Hungarian Old_Italic Old_North_Arabian Old_Permic Old_Persian Old_South_Arabian Old_Turkic Oriya Orkh Orya Osage Osge Osma Osmanya Pahawh_Hmong Palm Palmyrene Pau_Cin_Hau Pauc Perm Phag Phags_Pa Phli Phlp Phnx Phoenician Plrd Prti Psalter_Pahlavi Qaac Qaai Rejang Rjng Runic Runr Samaritan Samr Sarb Saur Saurashtra Sgnw Sharada Shavian Shaw Shrd Sidd Siddham SignWriting Sind Sinh Sinhala Sora Sora_Sompeng Soyo Soyombo Sund Sundanese Sylo Syloti_Nagri Syrc Syriac Tagalog Tagb Tagbanwa Tai_Le Tai_Tham Tai_Viet Takr Takri Tale Talu Tamil Taml Tang Tangut Tavt Telu Telugu Tfng Tglg Thaa Thaana Thai Tibetan Tibt Tifinagh Tirh Tirhuta Ugar Ugaritic Vai Vaii Wara Warang_Citi Xpeo Xsux Yi Yiii Zanabazar_Square Zanb Zinh Zyyy",
     "Dogr Dogra Gong Gunjala_Gondi Hanifi_Rohingya Maka Makasar Medefaidrin Medf Old_Sogdian Rohg Sogd Sogdian Sogo",
     "Elym Elymaic Hmnp Nand Nandinagari Nyiakeng_Puachue_Hmong Wancho Wcho",
     "Chorasmian Chrs Diak Dives_Akuru Khitan_Small_Script Kits Yezi Yezidi",
+    "Cpmn Cypro_Minoan Old_Uyghur Ougr Tangsa Tnsa Toto Vith Vithkuqi",
+    "Gara Garay Gukh Gurung_Khema Hrkt Katakana_Or_Hiragana Kawi Kirat_Rai Krai Nag_Mundari Nagm Ol_Onal Onao Sunu Sunuwar Todhri Todr Tulu_Tigalari Tutg Unknown Zzzz",
+    "",
+    "",
+    "",
 )
 const binPropertySets = new DataSet(
     "AHex ASCII ASCII_Hex_Digit Alpha Alphabetic Any Assigned Bidi_C Bidi_Control Bidi_M Bidi_Mirrored CI CWCF CWCM CWKCF CWL CWT CWU Case_Ignorable Cased Changes_When_Casefolded Changes_When_Casemapped Changes_When_Lowercased Changes_When_NFKC_Casefolded Changes_When_Titlecased Changes_When_Uppercased DI Dash Default_Ignorable_Code_Point Dep Deprecated Dia Diacritic Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Ext Extender Gr_Base Gr_Ext Grapheme_Base Grapheme_Extend Hex Hex_Digit IDC IDS IDSB IDST IDS_Binary_Operator IDS_Trinary_Operator ID_Continue ID_Start Ideo Ideographic Join_C Join_Control LOE Logical_Order_Exception Lower Lowercase Math NChar Noncharacter_Code_Point Pat_Syn Pat_WS Pattern_Syntax Pattern_White_Space QMark Quotation_Mark RI Radical Regional_Indicator SD STerm Sentence_Terminal Soft_Dotted Term Terminal_Punctuation UIdeo Unified_Ideograph Upper Uppercase VS Variation_Selector White_Space XIDC XIDS XID_Continue XID_Start space",
     "Extended_Pictographic",
     "",
     "EBase EComp EMod EPres ExtPict",
+    "",
+    "",
+    "",
+    "",
+    "",
+)
+const binPropertyOfStringsSets = new DataSet(
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "Basic_Emoji Emoji_Keycap_Sequence RGI_Emoji RGI_Emoji_Flag_Sequence RGI_Emoji_Modifier_Sequence RGI_Emoji_Tag_Sequence RGI_Emoji_ZWJ_Sequence",
+    "",
+    "",
 )
 
 export function isValidUnicodeProperty(
@@ -76,7 +174,9 @@ export function isValidUnicodeProperty(
             (version >= 2018 && scValueSets.es2018.has(value)) ||
             (version >= 2019 && scValueSets.es2019.has(value)) ||
             (version >= 2020 && scValueSets.es2020.has(value)) ||
-            (version >= 2021 && scValueSets.es2021.has(value))
+            (version >= 2021 && scValueSets.es2021.has(value)) ||
+            (version >= 2022 && scValueSets.es2022.has(value)) ||
+            (version >= 2023 && scValueSets.es2023.has(value))
         )
     }
     return false
@@ -92,3 +192,10 @@ export function isValidLoneUnicodeProperty(
         (version >= 2021 && binPropertySets.es2021.has(value))
     )
 }
+
+export function isValidLoneUnicodePropertyOfString(
+    version: number,
+    value: string,
+): boolean {
+    return version >= 2024 && binPropertyOfStringsSets.es2024.has(value)
+}
diff --git a/src/validator.ts b/src/validator.ts
index 29b5740..c6c9574 100644
--- a/src/validator.ts
+++ b/src/validator.ts
@@ -1,65 +1,72 @@
-import { EcmaVersion } from "./ecma-versions"
+import type { Flags } from "./ast"
+import type { EcmaVersion } from "./ecma-versions"
+import { latestEcmaVersion } from "./ecma-versions"
+import type { GroupSpecifiers } from "./group-specifiers"
+import {
+    GroupSpecifiersAsES2018,
+    GroupSpecifiersAsES2025,
+} from "./group-specifiers"
 import { Reader } from "./reader"
-import { RegExpSyntaxError } from "./regexp-syntax-error"
+import { newRegExpSyntaxError } from "./regexp-syntax-error"
 import {
-    Asterisk,
-    Backspace,
-    CarriageReturn,
-    CharacterTabulation,
-    CircumflexAccent,
-    Colon,
-    Comma,
-    DigitNine,
-    DigitOne,
+    ASTERISK,
+    BACKSPACE,
+    CARRIAGE_RETURN,
+    CHARACTER_TABULATION,
+    CIRCUMFLEX_ACCENT,
+    COLON,
+    COMMA,
+    DIGIT_NINE,
+    DIGIT_ONE,
     digitToInt,
-    DigitZero,
-    DollarSign,
-    EqualsSign,
-    ExclamationMark,
-    FormFeed,
-    FullStop,
-    GreaterThanSign,
-    HyphenMinus,
-    LatinCapitalLetterB,
-    LatinCapitalLetterD,
-    LatinCapitalLetterP,
-    LatinCapitalLetterS,
-    LatinCapitalLetterW,
-    LatinSmallLetterB,
-    LatinSmallLetterC,
-    LatinSmallLetterD,
-    LatinSmallLetterF,
-    LatinSmallLetterG,
-    LatinSmallLetterI,
-    LatinSmallLetterK,
-    LatinSmallLetterM,
-    LatinSmallLetterN,
-    LatinSmallLetterP,
-    LatinSmallLetterR,
-    LatinSmallLetterS,
-    LatinSmallLetterT,
-    LatinSmallLetterU,
-    LatinSmallLetterV,
-    LatinSmallLetterW,
-    LatinSmallLetterX,
-    LatinSmallLetterY,
-    LeftCurlyBracket,
-    LeftParenthesis,
-    LeftSquareBracket,
-    LessThanSign,
-    LineFeed,
-    LineTabulation,
-    LowLine,
-    PlusSign,
-    QuestionMark,
-    ReverseSolidus,
-    RightCurlyBracket,
-    RightParenthesis,
-    RightSquareBracket,
-    Solidus,
-    VerticalLine,
-    ZeroWidthJoiner,
-    ZeroWidthNonJoiner,
+    DIGIT_ZERO,
+    DOLLAR_SIGN,
+    EQUALS_SIGN,
+    EXCLAMATION_MARK,
+    FORM_FEED,
+    FULL_STOP,
+    GREATER_THAN_SIGN,
+    HYPHEN_MINUS,
+    LATIN_CAPITAL_LETTER_B,
+    LATIN_CAPITAL_LETTER_D,
+    LATIN_CAPITAL_LETTER_P,
+    LATIN_CAPITAL_LETTER_S,
+    LATIN_CAPITAL_LETTER_W,
+    LATIN_SMALL_LETTER_B,
+    LATIN_SMALL_LETTER_C,
+    LATIN_SMALL_LETTER_D,
+    LATIN_SMALL_LETTER_F,
+    LATIN_SMALL_LETTER_G,
+    LATIN_SMALL_LETTER_I,
+    LATIN_SMALL_LETTER_K,
+    LATIN_SMALL_LETTER_M,
+    LATIN_SMALL_LETTER_N,
+    LATIN_SMALL_LETTER_P,
+    LATIN_SMALL_LETTER_R,
+    LATIN_SMALL_LETTER_S,
+    LATIN_SMALL_LETTER_T,
+    LATIN_SMALL_LETTER_U,
+    LATIN_SMALL_LETTER_V,
+    LATIN_SMALL_LETTER_W,
+    LATIN_SMALL_LETTER_X,
+    LATIN_SMALL_LETTER_Y,
+    LEFT_CURLY_BRACKET,
+    LEFT_PARENTHESIS,
+    LEFT_SQUARE_BRACKET,
+    LESS_THAN_SIGN,
+    LINE_FEED,
+    LINE_TABULATION,
+    LOW_LINE,
+    PLUS_SIGN,
+    QUESTION_MARK,
+    REVERSE_SOLIDUS,
+    RIGHT_CURLY_BRACKET,
+    RIGHT_PARENTHESIS,
+    RIGHT_SQUARE_BRACKET,
+    SOLIDUS,
+    VERTICAL_LINE,
+    ZERO_WIDTH_JOINER,
+    ZERO_WIDTH_NON_JOINER,
     combineSurrogatePair,
     isDecimalDigit,
     isHexDigit,
@@ -72,50 +79,185 @@ import {
     isTrailSurrogate,
     isValidLoneUnicodeProperty,
     isValidUnicodeProperty,
+    isValidLoneUnicodePropertyOfString,
     isValidUnicode,
+    AMPERSAND,
+    NUMBER_SIGN,
+    PERCENT_SIGN,
+    SEMICOLON,
+    COMMERCIAL_AT,
+    GRAVE_ACCENT,
+    TILDE,
+    LATIN_SMALL_LETTER_Q,
 } from "./unicode"
 
+// ^ $ \ . * + ? ( ) [ ] { } |
+const SYNTAX_CHARACTER = new Set([
+    CIRCUMFLEX_ACCENT,
+    DOLLAR_SIGN,
+    REVERSE_SOLIDUS,
+    FULL_STOP,
+    ASTERISK,
+    PLUS_SIGN,
+    QUESTION_MARK,
+    LEFT_PARENTHESIS,
+    RIGHT_PARENTHESIS,
+    LEFT_SQUARE_BRACKET,
+    RIGHT_SQUARE_BRACKET,
+    LEFT_CURLY_BRACKET,
+    RIGHT_CURLY_BRACKET,
+    VERTICAL_LINE,
+])
+// && !! ## $$ %% ** ++ ,, .. :: ;; << == >> ?? @@ ^^ `` ~~
+const CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR_CHARACTER = new Set([
+    AMPERSAND,
+    EXCLAMATION_MARK,
+    NUMBER_SIGN,
+    DOLLAR_SIGN,
+    PERCENT_SIGN,
+    ASTERISK,
+    PLUS_SIGN,
+    COMMA,
+    FULL_STOP,
+    COLON,
+    SEMICOLON,
+    LESS_THAN_SIGN,
+    EQUALS_SIGN,
+    GREATER_THAN_SIGN,
+    QUESTION_MARK,
+    COMMERCIAL_AT,
+    CIRCUMFLEX_ACCENT,
+    GRAVE_ACCENT,
+    TILDE,
+])
+// ( ) [ ] { } / - \ |
+const CLASS_SET_SYNTAX_CHARACTER = new Set([
+    LEFT_PARENTHESIS,
+    RIGHT_PARENTHESIS,
+    LEFT_SQUARE_BRACKET,
+    RIGHT_SQUARE_BRACKET,
+    LEFT_CURLY_BRACKET,
+    RIGHT_CURLY_BRACKET,
+    SOLIDUS,
+    HYPHEN_MINUS,
+    REVERSE_SOLIDUS,
+    VERTICAL_LINE,
+])
+// & - ! # % , : ; < = > @ ` ~
+const CLASS_SET_RESERVED_PUNCTUATOR = new Set([
+    AMPERSAND,
+    HYPHEN_MINUS,
+    EXCLAMATION_MARK,
+    NUMBER_SIGN,
+    PERCENT_SIGN,
+    COMMA,
+    COLON,
+    SEMICOLON,
+    LESS_THAN_SIGN,
+    EQUALS_SIGN,
+    GREATER_THAN_SIGN,
+    COMMERCIAL_AT,
+    GRAVE_ACCENT,
+    TILDE,
+])
+
+const FLAG_PROP_TO_CODEPOINT = {
+    global: LATIN_SMALL_LETTER_G,
+    ignoreCase: LATIN_SMALL_LETTER_I,
+    multiline: LATIN_SMALL_LETTER_M,
+    unicode: LATIN_SMALL_LETTER_U,
+    sticky: LATIN_SMALL_LETTER_Y,
+    dotAll: LATIN_SMALL_LETTER_S,
+    hasIndices: LATIN_SMALL_LETTER_D,
+    unicodeSets: LATIN_SMALL_LETTER_V,
+} as const
+const FLAG_CODEPOINT_TO_PROP: Record<FlagCodePoint, FlagProp> =
+    Object.fromEntries(
+        Object.entries(FLAG_PROP_TO_CODEPOINT).map(([k, v]) => [v, k]),
+    ) as never
+type FlagProp = keyof typeof FLAG_PROP_TO_CODEPOINT
+type FlagCodePoint = (typeof FLAG_PROP_TO_CODEPOINT)[FlagProp]
+type FlagsRecord = Omit<Flags, "end" | "parent" | "raw" | "start" | "type">
+
 function isSyntaxCharacter(cp: number): boolean {
-    return (
-        cp === CircumflexAccent ||
-        cp === DollarSign ||
-        cp === ReverseSolidus ||
-        cp === FullStop ||
-        cp === Asterisk ||
-        cp === PlusSign ||
-        cp === QuestionMark ||
-        cp === LeftParenthesis ||
-        cp === RightParenthesis ||
-        cp === LeftSquareBracket ||
-        cp === RightSquareBracket ||
-        cp === LeftCurlyBracket ||
-        cp === RightCurlyBracket ||
-        cp === VerticalLine
-    )
+    // ^ $ \ . * + ? ( ) [ ] { } |
+    return SYNTAX_CHARACTER.has(cp)
+}
+
+function isClassSetReservedDoublePunctuatorCharacter(cp: number): boolean {
+    // && !! ## $$ %% ** ++ ,, .. :: ;; << == >> ?? @@ ^^ `` ~~
+    return CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR_CHARACTER.has(cp)
+}
+
+function isClassSetSyntaxCharacter(cp: number): boolean {
+    // ( ) [ ] { } / - \ |
+    return CLASS_SET_SYNTAX_CHARACTER.has(cp)
 }
 
-function isRegExpIdentifierStart(cp: number): boolean {
-    return isIdStart(cp) || cp === DollarSign || cp === LowLine
+function isClassSetReservedPunctuator(cp: number): boolean {
+    // & - ! # % , : ; < = > @ ` ~
+    return CLASS_SET_RESERVED_PUNCTUATOR.has(cp)
 }
 
-function isRegExpIdentifierPart(cp: number): boolean {
+/**
+ * ```
+ * IdentifierStartChar ::
+ *     UnicodeIDStart
+ *     $
+ *     _
+ * ```
+ */
+function isIdentifierStartChar(cp: number): boolean {
+    return isIdStart(cp) || cp === DOLLAR_SIGN || cp === LOW_LINE
+}
+
+/**
+ * ```
+ * IdentifierPartChar ::
+ *     UnicodeIDContinue
+ *     $
+ *     <ZWNJ>
+ *     <ZWJ>
+ * ```
+ */
+function isIdentifierPartChar(cp: number): boolean {
     return (
         isIdContinue(cp) ||
-        cp === DollarSign ||
-        cp === LowLine ||
-        cp === ZeroWidthNonJoiner ||
-        cp === ZeroWidthJoiner
+        cp === DOLLAR_SIGN ||
+        cp === ZERO_WIDTH_NON_JOINER ||
+        cp === ZERO_WIDTH_JOINER
     )
 }
 
 function isUnicodePropertyNameCharacter(cp: number): boolean {
-    return isLatinLetter(cp) || cp === LowLine
+    return isLatinLetter(cp) || cp === LOW_LINE
 }
 
 function isUnicodePropertyValueCharacter(cp: number): boolean {
     return isUnicodePropertyNameCharacter(cp) || isDecimalDigit(cp)
 }
 
+/**
+ * ```
+ * RegularExpressionModifier :: one of
+ *   `i` `m` `s`
+ * ```
+ */
+function isRegularExpressionModifier(ch: number): boolean {
+    return (
+        ch === LATIN_SMALL_LETTER_I ||
+        ch === LATIN_SMALL_LETTER_M ||
+        ch === LATIN_SMALL_LETTER_S
+    )
+}
+
+export type RegExpValidatorSourceContext = {
+    readonly source: string
+    readonly start: number
+    readonly end: number
+    readonly kind: "flags" | "literal" | "pattern"
+}
+
 export namespace RegExpValidator {
     /**
      * The options for RegExpValidator construction.
@@ -127,12 +269,15 @@ export namespace RegExpValidator {
         strict?: boolean
 
         /**
-         * ECMAScript version. Default is `2022`.
+         * ECMAScript version. Default is `2025`.
          * - `2015` added `u` and `y` flags.
          * - `2018` added `s` flag, Named Capturing Group, Lookbehind Assertion,
          *   and Unicode Property Escape.
          * - `2019`, `2020`, and `2021` added more valid Unicode Property Escapes.
          * - `2022` added `d` flag.
+         * - `2023` added more valid Unicode Property Escapes.
+         * - `2024` added `v` flag.
+         * - `2025` added duplicate named capturing groups, modifiers.
          */
         ecmaVersion?: EcmaVersion
 
@@ -140,15 +285,42 @@ export namespace RegExpValidator {
          * A function that is called when the validator entered a RegExp literal.
          * @param start The 0-based index of the first character.
          */
-        onLiteralEnter?(start: number): void
+        onLiteralEnter?: (start: number) => void
 
         /**
          * A function that is called when the validator left a RegExp literal.
          * @param start The 0-based index of the first character.
          * @param end The next 0-based index of the last character.
          */
-        onLiteralLeave?(start: number, end: number): void
+        onLiteralLeave?: (start: number, end: number) => void
 
+        /**
+         * A function that is called when the validator found flags.
+         * @param start The 0-based index of the first character.
+         * @param end The next 0-based index of the last character.
+         * @param flags.global `g` flag.
+         * @param flags.ignoreCase `i` flag.
+         * @param flags.multiline `m` flag.
+         * @param flags.unicode `u` flag.
+         * @param flags.sticky `y` flag.
+         * @param flags.dotAll `s` flag.
+         * @param flags.hasIndices `d` flag.
+         * @param flags.unicodeSets `v` flag.
+         */
+        onRegExpFlags?: (
+            start: number,
+            end: number,
+            flags: {
+                global: boolean
+                ignoreCase: boolean
+                multiline: boolean
+                unicode: boolean
+                sticky: boolean
+                dotAll: boolean
+                hasIndices: boolean
+                unicodeSets: boolean
+            },
+        ) => void
         /**
          * A function that is called when the validator found flags.
          * @param start The 0-based index of the first character.
@@ -160,8 +332,10 @@ export namespace RegExpValidator {
          * @param sticky `y` flag.
          * @param dotAll `s` flag.
          * @param hasIndices `d` flag.
+         *
+         * @deprecated Use `onRegExpFlags` instead.
          */
-        onFlags?(
+        onFlags?: (
             start: number,
             end: number,
             global: boolean,
@@ -171,40 +345,40 @@ export namespace RegExpValidator {
             sticky: boolean,
             dotAll: boolean,
             hasIndices: boolean,
-        ): void
+        ) => void
 
         /**
          * A function that is called when the validator entered a pattern.
          * @param start The 0-based index of the first character.
          */
-        onPatternEnter?(start: number): void
+        onPatternEnter?: (start: number) => void
 
         /**
          * A function that is called when the validator left a pattern.
          * @param start The 0-based index of the first character.
          * @param end The next 0-based index of the last character.
          */
-        onPatternLeave?(start: number, end: number): void
+        onPatternLeave?: (start: number, end: number) => void
 
         /**
          * A function that is called when the validator entered a disjunction.
          * @param start The 0-based index of the first character.
          */
-        onDisjunctionEnter?(start: number): void
+        onDisjunctionEnter?: (start: number) => void
 
         /**
          * A function that is called when the validator left a disjunction.
          * @param start The 0-based index of the first character.
          * @param end The next 0-based index of the last character.
          */
-        onDisjunctionLeave?(start: number, end: number): void
+        onDisjunctionLeave?: (start: number, end: number) => void
 
         /**
          * A function that is called when the validator entered an alternative.
          * @param start The 0-based index of the first character.
          * @param index The 0-based index of alternatives in a disjunction.
          */
-        onAlternativeEnter?(start: number, index: number): void
+        onAlternativeEnter?: (start: number, index: number) => void
 
         /**
          * A function that is called when the validator left an alternative.
@@ -212,27 +386,78 @@ export namespace RegExpValidator {
          * @param end The next 0-based index of the last character.
          * @param index The 0-based index of alternatives in a disjunction.
          */
-        onAlternativeLeave?(start: number, end: number, index: number): void
+        onAlternativeLeave?: (start: number, end: number, index: number) => void
 
         /**
          * A function that is called when the validator entered an uncapturing group.
          * @param start The 0-based index of the first character.
          */
-        onGroupEnter?(start: number): void
+        onGroupEnter?: (start: number) => void
 
         /**
          * A function that is called when the validator left an uncapturing group.
          * @param start The 0-based index of the first character.
          * @param end The next 0-based index of the last character.
          */
-        onGroupLeave?(start: number, end: number): void
+        onGroupLeave?: (start: number, end: number) => void
+
+        /**
+         * A function that is called when the validator entered a modifiers.
+         * @param start The 0-based index of the first character.
+         */
+        onModifiersEnter?: (start: number) => void
+
+        /**
+         * A function that is called when the validator left a modifiers.
+         * @param start The 0-based index of the first character.
+         * @param end The next 0-based index of the last character.
+         */
+        onModifiersLeave?: (start: number, end: number) => void
+
+        /**
+         * A function that is called when the validator found an add modifiers.
+         * @param start The 0-based index of the first character.
+         * @param end The next 0-based index of the last character.
+         * @param flags flags.
+         * @param flags.ignoreCase `i` flag.
+         * @param flags.multiline `m` flag.
+         * @param flags.dotAll `s` flag.
+         */
+        onAddModifiers?: (
+            start: number,
+            end: number,
+            flags: {
+                ignoreCase: boolean
+                multiline: boolean
+                dotAll: boolean
+            },
+        ) => void
+
+        /**
+         * A function that is called when the validator found a remove modifiers.
+         * @param start The 0-based index of the first character.
+         * @param end The next 0-based index of the last character.
+         * @param flags flags.
+         * @param flags.ignoreCase `i` flag.
+         * @param flags.multiline `m` flag.
+         * @param flags.dotAll `s` flag.
+         */
+        onRemoveModifiers?: (
+            start: number,
+            end: number,
+            flags: {
+                ignoreCase: boolean
+                multiline: boolean
+                dotAll: boolean
+            },
+        ) => void
 
         /**
          * A function that is called when the validator entered a capturing group.
          * @param start The 0-based index of the first character.
          * @param name The group name.
          */
-        onCapturingGroupEnter?(start: number, name: string | null): void
+        onCapturingGroupEnter?: (start: number, name: string | null) => void
 
         /**
          * A function that is called when the validator left a capturing group.
@@ -240,11 +465,11 @@ export namespace RegExpValidator {
          * @param end The next 0-based index of the last character.
          * @param name The group name.
          */
-        onCapturingGroupLeave?(
+        onCapturingGroupLeave?: (
             start: number,
             end: number,
             name: string | null,
-        ): void
+        ) => void
 
         /**
          * A function that is called when the validator found a quantifier.
@@ -254,13 +479,13 @@ export namespace RegExpValidator {
          * @param max The maximum number of repeating.
          * @param greedy The flag to choose the longest matching.
          */
-        onQuantifier?(
+        onQuantifier?: (
             start: number,
             end: number,
             min: number,
             max: number,
             greedy: boolean,
-        ): void
+        ) => void
 
         /**
          * A function that is called when the validator entered a lookahead/lookbehind assertion.
@@ -268,11 +493,11 @@ export namespace RegExpValidator {
          * @param kind The kind of the assertion.
          * @param negate The flag which represents that the assertion is negative.
          */
-        onLookaroundAssertionEnter?(
+        onLookaroundAssertionEnter?: (
             start: number,
             kind: "lookahead" | "lookbehind",
             negate: boolean,
-        ): void
+        ) => void
 
         /**
          * A function that is called when the validator left a lookahead/lookbehind assertion.
@@ -281,12 +506,12 @@ export namespace RegExpValidator {
          * @param kind The kind of the assertion.
          * @param negate The flag which represents that the assertion is negative.
          */
-        onLookaroundAssertionLeave?(
+        onLookaroundAssertionLeave?: (
             start: number,
             end: number,
             kind: "lookahead" | "lookbehind",
             negate: boolean,
-        ): void
+        ) => void
 
         /**
          * A function that is called when the validator found an edge boundary assertion.
@@ -294,11 +519,11 @@ export namespace RegExpValidator {
          * @param end The next 0-based index of the last character.
          * @param kind The kind of the assertion.
          */
-        onEdgeAssertion?(
+        onEdgeAssertion?: (
             start: number,
             end: number,
-            kind: "start" | "end",
-        ): void
+            kind: "end" | "start",
+        ) => void
 
         /**
          * A function that is called when the validator found a word boundary assertion.
@@ -307,12 +532,12 @@ export namespace RegExpValidator {
          * @param kind The kind of the assertion.
          * @param negate The flag which represents that the assertion is negative.
          */
-        onWordBoundaryAssertion?(
+        onWordBoundaryAssertion?: (
             start: number,
             end: number,
             kind: "word",
             negate: boolean,
-        ): void
+        ) => void
 
         /**
          * A function that is called when the validator found a dot.
@@ -320,7 +545,7 @@ export namespace RegExpValidator {
          * @param end The next 0-based index of the last character.
          * @param kind The kind of the character set.
          */
-        onAnyCharacterSet?(start: number, end: number, kind: "any"): void
+        onAnyCharacterSet?: (start: number, end: number, kind: "any") => void
 
         /**
          * A function that is called when the validator found a character set escape.
@@ -329,12 +554,12 @@ export namespace RegExpValidator {
          * @param kind The kind of the character set.
          * @param negate The flag which represents that the character set is negative.
          */
-        onEscapeCharacterSet?(
+        onEscapeCharacterSet?: (
             start: number,
             end: number,
             kind: "digit" | "space" | "word",
             negate: boolean,
-        ): void
+        ) => void
 
         /**
          * A function that is called when the validator found a Unicode proerty escape.
@@ -344,15 +569,17 @@ export namespace RegExpValidator {
          * @param key The property name.
          * @param value The property value.
          * @param negate The flag which represents that the character set is negative.
+         * @param strings If true, the given property is property of strings.
          */
-        onUnicodePropertyCharacterSet?(
+        onUnicodePropertyCharacterSet?: (
             start: number,
             end: number,
             kind: "property",
             key: string,
             value: string | null,
             negate: boolean,
-        ): void
+            strings: boolean,
+        ) => void
 
         /**
          * A function that is called when the validator found a character.
@@ -360,7 +587,7 @@ export namespace RegExpValidator {
          * @param end The next 0-based index of the last character.
          * @param value The code point of the character.
          */
-        onCharacter?(start: number, end: number, value: number): void
+        onCharacter?: (start: number, end: number, value: number) => void
 
         /**
          * A function that is called when the validator found a backreference.
@@ -368,14 +595,23 @@ export namespace RegExpValidator {
          * @param end The next 0-based index of the last character.
          * @param ref The key of the referred capturing group.
          */
-        onBackreference?(start: number, end: number, ref: number | string): void
+        onBackreference?: (
+            start: number,
+            end: number,
+            ref: number | string,
+        ) => void
 
         /**
          * A function that is called when the validator entered a character class.
          * @param start The 0-based index of the first character.
          * @param negate The flag which represents that the character class is negative.
+         * @param unicodeSets `true` if unicodeSets mode.
          */
-        onCharacterClassEnter?(start: number, negate: boolean): void
+        onCharacterClassEnter?: (
+            start: number,
+            negate: boolean,
+            unicodeSets: boolean,
+        ) => void
 
         /**
          * A function that is called when the validator left a character class.
@@ -383,11 +619,11 @@ export namespace RegExpValidator {
          * @param end The next 0-based index of the last character.
          * @param negate The flag which represents that the character class is negative.
          */
-        onCharacterClassLeave?(
+        onCharacterClassLeave?: (
             start: number,
             end: number,
             negate: boolean,
-        ): void
+        ) => void
 
         /**
          * A function that is called when the validator found a character class range.
@@ -396,40 +632,111 @@ export namespace RegExpValidator {
          * @param min The minimum code point of the range.
          * @param max The maximum code point of the range.
          */
-        onCharacterClassRange?(
+        onCharacterClassRange?: (
             start: number,
             end: number,
             min: number,
             max: number,
-        ): void
+        ) => void
+
+        /**
+         * A function that is called when the validator found a class intersection.
+         * @param start The 0-based index of the first character.
+         * @param end The next 0-based index of the last character.
+         */
+        onClassIntersection?: (start: number, end: number) => void
+
+        /**
+         * A function that is called when the validator found a class subtraction.
+         * @param start The 0-based index of the first character.
+         * @param end The next 0-based index of the last character.
+         */
+        onClassSubtraction?: (start: number, end: number) => void
+
+        /**
+         * A function that is called when the validator entered a class string disjunction.
+         * @param start The 0-based index of the first character.
+         */
+        onClassStringDisjunctionEnter?: (start: number) => void
+
+        /**
+         * A function that is called when the validator left a class string disjunction.
+         * @param start The 0-based index of the first character.
+         * @param end The next 0-based index of the last character.
+         */
+        onClassStringDisjunctionLeave?: (start: number, end: number) => void
+
+        /**
+         * A function that is called when the validator entered a string alternative.
+         * @param start The 0-based index of the first character.
+         * @param index The 0-based index of alternatives in a disjunction.
+         */
+        onStringAlternativeEnter?: (start: number, index: number) => void
+
+        /**
+         * A function that is called when the validator left a string alternative.
+         * @param start The 0-based index of the first character.
+         * @param end The next 0-based index of the last character.
+         * @param index The 0-based index of alternatives in a disjunction.
+         */
+        onStringAlternativeLeave?: (
+            start: number,
+            end: number,
+            index: number,
+        ) => void
     }
 }
 
+type UnicodeSetsConsumeResult = { mayContainStrings?: boolean }
+type UnicodePropertyValueExpressionConsumeResult = {
+    key: string
+    value: string | null
+    strings?: boolean
+}
+
 /**
  * The regular expression validator.
  */
 export class RegExpValidator {
     private readonly _options: RegExpValidator.Options
+
     private readonly _reader = new Reader()
-    private _uFlag = false
+
+    private _unicodeMode = false
+
+    private _unicodeSetsMode = false
+
     private _nFlag = false
+
     private _lastIntValue = 0
-    private _lastMinValue = 0
-    private _lastMaxValue = 0
+
+    private _lastRange = {
+        min: 0,
+        max: Number.POSITIVE_INFINITY,
+    }
+
     private _lastStrValue = ""
-    private _lastKeyValue = ""
-    private _lastValValue = ""
+
     private _lastAssertionIsQuantifiable = false
+
     private _numCapturingParens = 0
-    private _groupNames = new Set<string>()
+
+    private _groupSpecifiers: GroupSpecifiers
+
     private _backreferenceNames = new Set<string>()
 
+    private _srcCtx: RegExpValidatorSourceContext | null = null
+
     /**
      * Initialize this validator.
      * @param options The options of validator.
      */
     public constructor(options?: RegExpValidator.Options) {
-        this._options = options || {}
+        this._options = options ?? {}
+        this._groupSpecifiers =
+            this.ecmaVersion >= 2025
+                ? new GroupSpecifiersAsES2025()
+                : new GroupSpecifiersAsES2018()
     }
 
     /**
@@ -443,15 +750,20 @@ export class RegExpValidator {
         start = 0,
         end: number = source.length,
     ): void {
-        this._uFlag = this._nFlag = false
+        this._srcCtx = { source, start, end, kind: "literal" }
+        this._unicodeSetsMode = this._unicodeMode = this._nFlag = false
         this.reset(source, start, end)
 
         this.onLiteralEnter(start)
-        if (this.eat(Solidus) && this.eatRegExpBody() && this.eat(Solidus)) {
+        if (this.eat(SOLIDUS) && this.eatRegExpBody() && this.eat(SOLIDUS)) {
             const flagStart = this.index
-            const uFlag = source.includes("u", flagStart)
-            this.validateFlags(source, flagStart, end)
-            this.validatePattern(source, start + 1, flagStart - 1, uFlag)
+            const unicode = source.includes("u", flagStart)
+            const unicodeSets = source.includes("v", flagStart)
+            this.validateFlagsInternal(source, flagStart, end)
+            this.validatePatternInternal(source, start + 1, flagStart - 1, {
+                unicode,
+                unicodeSets,
+            })
         } else if (start >= end) {
             this.raise("Empty")
         } else {
@@ -472,51 +784,8 @@ export class RegExpValidator {
         start = 0,
         end: number = source.length,
     ): void {
-        const existingFlags = new Set<number>()
-        let global = false
-        let ignoreCase = false
-        let multiline = false
-        let sticky = false
-        let unicode = false
-        let dotAll = false
-        let hasIndices = false
-        for (let i = start; i < end; ++i) {
-            const flag = source.charCodeAt(i)
-
-            if (existingFlags.has(flag)) {
-                this.raise(`Duplicated flag '${source[i]}'`)
-            }
-            existingFlags.add(flag)
-
-            if (flag === LatinSmallLetterG) {
-                global = true
-            } else if (flag === LatinSmallLetterI) {
-                ignoreCase = true
-            } else if (flag === LatinSmallLetterM) {
-                multiline = true
-            } else if (flag === LatinSmallLetterU && this.ecmaVersion >= 2015) {
-                unicode = true
-            } else if (flag === LatinSmallLetterY && this.ecmaVersion >= 2015) {
-                sticky = true
-            } else if (flag === LatinSmallLetterS && this.ecmaVersion >= 2018) {
-                dotAll = true
-            } else if (flag === LatinSmallLetterD && this.ecmaVersion >= 2022) {
-                hasIndices = true
-            } else {
-                this.raise(`Invalid flag '${source[i]}'`)
-            }
-        }
-        this.onFlags(
-            start,
-            end,
-            global,
-            ignoreCase,
-            multiline,
-            unicode,
-            sticky,
-            dotAll,
-            hasIndices,
-        )
+        this._srcCtx = { source, start, end, kind: "flags" }
+        this.validateFlagsInternal(source, start, end)
     }
 
     /**
@@ -524,23 +793,71 @@ export class RegExpValidator {
      * @param source The source code to validate.
      * @param start The start index in the source code.
      * @param end The end index in the source code.
+     * @param flags The flags.
+     */
+    public validatePattern(
+        source: string,
+        start?: number,
+        end?: number,
+        flags?: {
+            unicode?: boolean
+            unicodeSets?: boolean
+        },
+    ): void
+    /**
+     * @deprecated Backward compatibility
+     * Use object `flags` instead of boolean `uFlag`.
+     * @param source The source code to validate.
+     * @param start The start index in the source code.
+     * @param end The end index in the source code.
      * @param uFlag The flag to set unicode mode.
      */
+    public validatePattern(
+        source: string,
+        start?: number,
+        end?: number,
+        uFlag?: boolean, // The unicode flag (backward compatibility).
+    ): void
     public validatePattern(
         source: string,
         start = 0,
         end: number = source.length,
-        uFlag = false,
+        uFlagOrFlags:
+            | boolean // The unicode flag (backward compatibility).
+            | {
+                  unicode?: boolean
+                  unicodeSets?: boolean
+              }
+            | undefined = undefined,
     ): void {
-        this._uFlag = uFlag && this.ecmaVersion >= 2015
-        this._nFlag = uFlag && this.ecmaVersion >= 2018
+        this._srcCtx = { source, start, end, kind: "pattern" }
+        this.validatePatternInternal(source, start, end, uFlagOrFlags)
+    }
+
+    private validatePatternInternal(
+        source: string,
+        start = 0,
+        end: number = source.length,
+        uFlagOrFlags:
+            | boolean // The unicode flag (backward compatibility).
+            | {
+                  unicode?: boolean
+                  unicodeSets?: boolean
+              }
+            | undefined = undefined,
+    ): void {
+        const mode = this._parseFlagsOptionToMode(uFlagOrFlags, end)
+
+        this._unicodeMode = mode.unicodeMode
+        this._nFlag = mode.nFlag
+        this._unicodeSetsMode = mode.unicodeSetsMode
         this.reset(source, start, end)
         this.consumePattern()
 
         if (
             !this._nFlag &&
             this.ecmaVersion >= 2018 &&
-            this._groupNames.size > 0
+            !this._groupSpecifiers.isEmpty()
         ) {
             this._nFlag = true
             this.rewind(start)
@@ -548,14 +865,72 @@ export class RegExpValidator {
         }
     }
 
+    private validateFlagsInternal(
+        source: string,
+        start: number,
+        end: number,
+    ): void {
+        const flags = this.parseFlags(source, start, end)
+        this.onRegExpFlags(start, end, flags)
+    }
+
+    private _parseFlagsOptionToMode(
+        uFlagOrFlags:
+            | boolean // The unicode flag (backward compatibility).
+            | {
+                  unicode?: boolean
+                  unicodeSets?: boolean
+              }
+            | undefined,
+        sourceEnd: number,
+    ): {
+        unicodeMode: boolean
+        nFlag: boolean
+        unicodeSetsMode: boolean
+    } {
+        let unicode = false
+        let unicodeSets = false
+        if (uFlagOrFlags && this.ecmaVersion >= 2015) {
+            if (typeof uFlagOrFlags === "object") {
+                unicode = Boolean(uFlagOrFlags.unicode)
+                if (this.ecmaVersion >= 2024) {
+                    unicodeSets = Boolean(uFlagOrFlags.unicodeSets)
+                }
+            } else {
+                // uFlagOrFlags is unicode flag (backward compatibility).
+                unicode = uFlagOrFlags
+            }
+        }
+
+        if (unicode && unicodeSets) {
+            // 1. If v is true and u is true, then
+            //   a. Let parseResult be a List containing one SyntaxError object.
+            this.raise("Invalid regular expression flags", {
+                index: sourceEnd + 1 /* `/` */,
+                unicode,
+                unicodeSets,
+            })
+        }
+
+        const unicodeMode = unicode || unicodeSets
+        const nFlag =
+            (unicode && this.ecmaVersion >= 2018) ||
+            unicodeSets ||
+            // Introduced as Normative Change in ES2023
+            // See https://github.com/tc39/ecma262/pull/2436
+            Boolean(this._options.strict && this.ecmaVersion >= 2023)
+        const unicodeSetsMode = unicodeSets
+
+        return { unicodeMode, nFlag, unicodeSetsMode }
+    }
     // #region Delegate for Options
 
     private get strict() {
-        return Boolean(this._options.strict || this._uFlag)
+        return Boolean(this._options.strict) || this._unicodeMode
     }
 
     private get ecmaVersion() {
-        return this._options.ecmaVersion || 2022
+        return this._options.ecmaVersion ?? latestEcmaVersion
     }
 
     private onLiteralEnter(start: number): void {
@@ -570,28 +945,35 @@ export class RegExpValidator {
         }
     }
 
-    private onFlags(
+    private onRegExpFlags(
         start: number,
         end: number,
-        global: boolean,
-        ignoreCase: boolean,
-        multiline: boolean,
-        unicode: boolean,
-        sticky: boolean,
-        dotAll: boolean,
-        hasIndices: boolean,
+        flags: {
+            global: boolean
+            ignoreCase: boolean
+            multiline: boolean
+            unicode: boolean
+            sticky: boolean
+            dotAll: boolean
+            hasIndices: boolean
+            unicodeSets: boolean
+        },
     ): void {
+        if (this._options.onRegExpFlags) {
+            this._options.onRegExpFlags(start, end, flags)
+        }
+        // Backward compatibility
         if (this._options.onFlags) {
             this._options.onFlags(
                 start,
                 end,
-                global,
-                ignoreCase,
-                multiline,
-                unicode,
-                sticky,
-                dotAll,
-                hasIndices,
+                flags.global,
+                flags.ignoreCase,
+                flags.multiline,
+                flags.unicode,
+                flags.sticky,
+                flags.dotAll,
+                flags.hasIndices,
             )
         }
     }
@@ -648,6 +1030,38 @@ export class RegExpValidator {
         }
     }
 
+    private onModifiersEnter(start: number): void {
+        if (this._options.onModifiersEnter) {
+            this._options.onModifiersEnter(start)
+        }
+    }
+
+    private onModifiersLeave(start: number, end: number): void {
+        if (this._options.onModifiersLeave) {
+            this._options.onModifiersLeave(start, end)
+        }
+    }
+
+    private onAddModifiers(
+        start: number,
+        end: number,
+        flags: { ignoreCase: boolean; multiline: boolean; dotAll: boolean },
+    ): void {
+        if (this._options.onAddModifiers) {
+            this._options.onAddModifiers(start, end, flags)
+        }
+    }
+
+    private onRemoveModifiers(
+        start: number,
+        end: number,
+        flags: { ignoreCase: boolean; multiline: boolean; dotAll: boolean },
+    ): void {
+        if (this._options.onRemoveModifiers) {
+            this._options.onRemoveModifiers(start, end, flags)
+        }
+    }
+
     private onCapturingGroupEnter(start: number, name: string | null): void {
         if (this._options.onCapturingGroupEnter) {
             this._options.onCapturingGroupEnter(start, name)
@@ -700,7 +1114,7 @@ export class RegExpValidator {
     private onEdgeAssertion(
         start: number,
         end: number,
-        kind: "start" | "end",
+        kind: "end" | "start",
     ): void {
         if (this._options.onEdgeAssertion) {
             this._options.onEdgeAssertion(start, end, kind)
@@ -742,6 +1156,7 @@ export class RegExpValidator {
         key: string,
         value: string | null,
         negate: boolean,
+        strings: boolean,
     ): void {
         if (this._options.onUnicodePropertyCharacterSet) {
             this._options.onUnicodePropertyCharacterSet(
@@ -751,6 +1166,7 @@ export class RegExpValidator {
                 key,
                 value,
                 negate,
+                strings,
             )
         }
     }
@@ -771,9 +1187,13 @@ export class RegExpValidator {
         }
     }
 
-    private onCharacterClassEnter(start: number, negate: boolean): void {
+    private onCharacterClassEnter(
+        start: number,
+        negate: boolean,
+        unicodeSets: boolean,
+    ): void {
         if (this._options.onCharacterClassEnter) {
-            this._options.onCharacterClassEnter(start, negate)
+            this._options.onCharacterClassEnter(start, negate, unicodeSets)
         }
     }
 
@@ -798,14 +1218,50 @@ export class RegExpValidator {
         }
     }
 
-    // #endregion
+    private onClassIntersection(start: number, end: number): void {
+        if (this._options.onClassIntersection) {
+            this._options.onClassIntersection(start, end)
+        }
+    }
 
-    // #region Delegate for Reader
+    private onClassSubtraction(start: number, end: number): void {
+        if (this._options.onClassSubtraction) {
+            this._options.onClassSubtraction(start, end)
+        }
+    }
+
+    private onClassStringDisjunctionEnter(start: number): void {
+        if (this._options.onClassStringDisjunctionEnter) {
+            this._options.onClassStringDisjunctionEnter(start)
+        }
+    }
 
-    private get source(): string {
-        return this._reader.source
+    private onClassStringDisjunctionLeave(start: number, end: number): void {
+        if (this._options.onClassStringDisjunctionLeave) {
+            this._options.onClassStringDisjunctionLeave(start, end)
+        }
+    }
+
+    private onStringAlternativeEnter(start: number, index: number): void {
+        if (this._options.onStringAlternativeEnter) {
+            this._options.onStringAlternativeEnter(start, index)
+        }
+    }
+
+    private onStringAlternativeLeave(
+        start: number,
+        end: number,
+        index: number,
+    ): void {
+        if (this._options.onStringAlternativeLeave) {
+            this._options.onStringAlternativeLeave(start, end, index)
+        }
     }
 
+    // #endregion
+
+    // #region Delegate for Reader
+
     private get index(): number {
         return this._reader.index
     }
@@ -827,7 +1283,7 @@ export class RegExpValidator {
     }
 
     private reset(source: string, start: number, end: number): void {
-        this._reader.reset(source, start, end, this._uFlag)
+        this._reader.reset(source, start, end, this._unicodeMode)
     }
 
     private rewind(index: number): void {
@@ -852,16 +1308,24 @@ export class RegExpValidator {
 
     // #endregion
 
-    private raise(message: string): never {
-        throw new RegExpSyntaxError(
-            this.source,
-            this._uFlag,
-            this.index,
+    private raise(
+        message: string,
+        context?: { index?: number; unicode?: boolean; unicodeSets?: boolean },
+    ): never {
+        throw newRegExpSyntaxError(
+            this._srcCtx!,
+            {
+                unicode:
+                    context?.unicode ??
+                    (this._unicodeMode && !this._unicodeSetsMode),
+                unicodeSets: context?.unicodeSets ?? this._unicodeSetsMode,
+            },
+            context?.index ?? this.index,
             message,
         )
     }
 
-    // https://www.ecma-international.org/ecma-262/8.0/#prod-RegularExpressionBody
+    // https://tc39.es/ecma262/2022/multipage/ecmascript-language-lexical-grammar.html#prod-RegularExpressionBody
     private eatRegExpBody(): boolean {
         const start = this.index
         let inClass = false
@@ -875,15 +1339,15 @@ export class RegExpValidator {
             }
             if (escaped) {
                 escaped = false
-            } else if (cp === ReverseSolidus) {
+            } else if (cp === REVERSE_SOLIDUS) {
                 escaped = true
-            } else if (cp === LeftSquareBracket) {
+            } else if (cp === LEFT_SQUARE_BRACKET) {
                 inClass = true
-            } else if (cp === RightSquareBracket) {
+            } else if (cp === RIGHT_SQUARE_BRACKET) {
                 inClass = false
             } else if (
-                (cp === Solidus && !inClass) ||
-                (cp === Asterisk && this.index === start)
+                (cp === SOLIDUS && !inClass) ||
+                (cp === ASTERISK && this.index === start)
             ) {
                 break
             }
@@ -896,14 +1360,14 @@ export class RegExpValidator {
     /**
      * Validate the next characters as a RegExp `Pattern` production.
      * ```
-     * Pattern[U, N]::
-     *      Disjunction[?U, ?N]
+     * Pattern[UnicodeMode, UnicodeSetsMode, N]::
+     *      Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?N]
      * ```
      */
     private consumePattern(): void {
         const start = this.index
         this._numCapturingParens = this.countCapturingParens()
-        this._groupNames.clear()
+        this._groupSpecifiers.clear()
         this._backreferenceNames.clear()
 
         this.onPatternEnter(start)
@@ -911,20 +1375,20 @@ export class RegExpValidator {
 
         const cp = this.currentCodePoint
         if (this.currentCodePoint !== -1) {
-            if (cp === RightParenthesis) {
+            if (cp === RIGHT_PARENTHESIS) {
                 this.raise("Unmatched ')'")
             }
-            if (cp === ReverseSolidus) {
+            if (cp === REVERSE_SOLIDUS) {
                 this.raise("\\ at end of pattern")
             }
-            if (cp === RightSquareBracket || cp === RightCurlyBracket) {
+            if (cp === RIGHT_SQUARE_BRACKET || cp === RIGHT_CURLY_BRACKET) {
                 this.raise("Lone quantifier brackets")
             }
             const c = String.fromCodePoint(cp)
             this.raise(`Unexpected character '${c}'`)
         }
         for (const name of this._backreferenceNames) {
-            if (!this._groupNames.has(name)) {
+            if (!this._groupSpecifiers.hasInPattern(name)) {
                 this.raise("Invalid named capture referenced")
             }
         }
@@ -945,19 +1409,19 @@ export class RegExpValidator {
         while ((cp = this.currentCodePoint) !== -1) {
             if (escaped) {
                 escaped = false
-            } else if (cp === ReverseSolidus) {
+            } else if (cp === REVERSE_SOLIDUS) {
                 escaped = true
-            } else if (cp === LeftSquareBracket) {
+            } else if (cp === LEFT_SQUARE_BRACKET) {
                 inClass = true
-            } else if (cp === RightSquareBracket) {
+            } else if (cp === RIGHT_SQUARE_BRACKET) {
                 inClass = false
             } else if (
-                cp === LeftParenthesis &&
+                cp === LEFT_PARENTHESIS &&
                 !inClass &&
-                (this.nextCodePoint !== QuestionMark ||
-                    (this.nextCodePoint2 === LessThanSign &&
-                        this.nextCodePoint3 !== EqualsSign &&
-                        this.nextCodePoint3 !== ExclamationMark))
+                (this.nextCodePoint !== QUESTION_MARK ||
+                    (this.nextCodePoint2 === LESS_THAN_SIGN &&
+                        this.nextCodePoint3 !== EQUALS_SIGN &&
+                        this.nextCodePoint3 !== EXCLAMATION_MARK))
             ) {
                 count += 1
             }
@@ -971,40 +1435,43 @@ export class RegExpValidator {
     /**
      * Validate the next characters as a RegExp `Disjunction` production.
      * ```
-     * Disjunction[U, N]::
-     *      Alternative[?U, ?N]
-     *      Alternative[?U, ?N] `|` Disjunction[?U, ?N]
+     * Disjunction[UnicodeMode, UnicodeSetsMode, N]::
+     *      Alternative[?UnicodeMode, ?UnicodeSetsMode, ?N]
+     *      Alternative[?UnicodeMode, ?UnicodeSetsMode, ?N] `|` Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?N]
      * ```
      */
     private consumeDisjunction(): void {
         const start = this.index
         let i = 0
 
+        this._groupSpecifiers.enterDisjunction()
         this.onDisjunctionEnter(start)
         do {
             this.consumeAlternative(i++)
-        } while (this.eat(VerticalLine))
+        } while (this.eat(VERTICAL_LINE))
 
         if (this.consumeQuantifier(true)) {
             this.raise("Nothing to repeat")
         }
-        if (this.eat(LeftCurlyBracket)) {
+        if (this.eat(LEFT_CURLY_BRACKET)) {
             this.raise("Lone quantifier brackets")
         }
         this.onDisjunctionLeave(start, this.index)
+        this._groupSpecifiers.leaveDisjunction()
     }
 
     /**
      * Validate the next characters as a RegExp `Alternative` production.
      * ```
-     * Alternative[U, N]::
-     *      ε
-     *      Alternative[?U, ?N] Term[?U, ?N]
+     * Alternative[UnicodeMode, UnicodeSetsMode, N]::
+     *      [empty]
+     *      Alternative[?UnicodeMode, ?UnicodeSetsMode, ?N] Term[?UnicodeMode, ?UnicodeSetsMode, ?N]
      * ```
      */
     private consumeAlternative(i: number): void {
         const start = this.index
 
+        this._groupSpecifiers.enterAlternative(i)
         this.onAlternativeEnter(start, i)
         while (this.currentCodePoint !== -1 && this.consumeTerm()) {
             // do nothing.
@@ -1015,22 +1482,22 @@ export class RegExpValidator {
     /**
      * Validate the next characters as a RegExp `Term` production if possible.
      * ```
-     * Term[U, N]::
-     *      [strict] Assertion[+U, ?N]
-     *      [strict] Atom[+U, ?N]
-     *      [strict] Atom[+U, ?N] Quantifier
-     *      [annexB][+U] Assertion[+U, ?N]
-     *      [annexB][+U] Atom[+U, ?N]
-     *      [annexB][+U] Atom[+U, ?N] Quantifier
-     *      [annexB][~U] QuantifiableAssertion[?N] Quantifier
-     *      [annexB][~U] Assertion[~U, ?N]
-     *      [annexB][~U] ExtendedAtom[?N] Quantifier
-     *      [annexB][~U] ExtendedAtom[?N]
+     * Term[UnicodeMode, UnicodeSetsMode, N]::
+     *      [strict] Assertion[?UnicodeMode, ?UnicodeSetsMode, ?N]
+     *      [strict] Atom[?UnicodeMode, ?UnicodeSetsMode, ?N]
+     *      [strict] Atom[?UnicodeMode, UnicodeSetsMode, ?N] Quantifier
+     *      [annexB][+UnicodeMode] Assertion[+UnicodeMode, ?N]
+     *      [annexB][+UnicodeMode] Atom[+UnicodeMode, ?N] Quantifier
+     *      [annexB][+UnicodeMode] Atom[+UnicodeMode, ?N]
+     *      [annexB][~UnicodeMode] QuantifiableAssertion[?N] Quantifier
+     *      [annexB][~UnicodeMode] Assertion[~UnicodeMode, ?N]
+     *      [annexB][~UnicodeMode] ExtendedAtom[?N] Quantifier
+     *      [annexB][~UnicodeMode] ExtendedAtom[?N]
      * ```
      * @returns `true` if it consumed the next characters successfully.
      */
     private consumeTerm(): boolean {
-        if (this._uFlag || this.strict) {
+        if (this._unicodeMode || this.strict) {
             return (
                 this.consumeAssertion() ||
                 (this.consumeAtom() && this.consumeOptionalQuantifier())
@@ -1043,6 +1510,7 @@ export class RegExpValidator {
             (this.consumeExtendedAtom() && this.consumeOptionalQuantifier())
         )
     }
+
     private consumeOptionalQuantifier(): boolean {
         this.consumeQuantifier()
         return true
@@ -1053,21 +1521,21 @@ export class RegExpValidator {
      * Set `this._lastAssertionIsQuantifiable` if the consumed assertion was a
      * `QuantifiableAssertion` production.
      * ```
-     * Assertion[U, N]::
+     * Assertion[UnicodeMode, UnicodeSetsMode, N]::
      *      `^`
      *      `$`
      *      `\b`
      *      `\B`
-     *      [strict] `(?=` Disjunction[+U, ?N] `)`
-     *      [strict] `(?!` Disjunction[+U, ?N] `)`
-     *      [annexB][+U] `(?=` Disjunction[+U, ?N] `)`
-     *      [annexB][+U] `(?!` Disjunction[+U, ?N] `)`
-     *      [annexB][~U] QuantifiableAssertion[?N]
-     *      `(?<=` Disjunction[?U, ?N] `)`
-     *      `(?<!` Disjunction[?U, ?N] `)`
+     *      [strict] `(?=` Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?N] `)`
+     *      [strict] `(?!` Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?N] `)`
+     *      [annexB][+UnicodeMode] `(?=` Disjunction[+UnicodeMode, ?N] `)`
+     *      [annexB][+UnicodeMode] `(?!` Disjunction[+UnicodeMode, ?N] `)`
+     *      [annexB][~UnicodeMode] QuantifiableAssertion[?N]
+     *      `(?<=` Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?N] `)`
+     *      `(?<!` Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?N] `)`
      * QuantifiableAssertion[N]::
-     *      `(?=` Disjunction[~U, ?N] `)`
-     *      `(?!` Disjunction[~U, ?N] `)`
+     *      `(?=` Disjunction[~UnicodeMode, ?N] `)`
+     *      `(?!` Disjunction[~UnicodeMode, ?N] `)`
      * ```
      * @returns `true` if it consumed the next characters successfully.
      */
@@ -1076,33 +1544,36 @@ export class RegExpValidator {
         this._lastAssertionIsQuantifiable = false
 
         // ^, $, \B \b
-        if (this.eat(CircumflexAccent)) {
+        if (this.eat(CIRCUMFLEX_ACCENT)) {
             this.onEdgeAssertion(start, this.index, "start")
             return true
         }
-        if (this.eat(DollarSign)) {
+        if (this.eat(DOLLAR_SIGN)) {
             this.onEdgeAssertion(start, this.index, "end")
             return true
         }
-        if (this.eat2(ReverseSolidus, LatinCapitalLetterB)) {
+        if (this.eat2(REVERSE_SOLIDUS, LATIN_CAPITAL_LETTER_B)) {
             this.onWordBoundaryAssertion(start, this.index, "word", true)
             return true
         }
-        if (this.eat2(ReverseSolidus, LatinSmallLetterB)) {
+        if (this.eat2(REVERSE_SOLIDUS, LATIN_SMALL_LETTER_B)) {
             this.onWordBoundaryAssertion(start, this.index, "word", false)
             return true
         }
 
         // Lookahead / Lookbehind
-        if (this.eat2(LeftParenthesis, QuestionMark)) {
+        if (this.eat2(LEFT_PARENTHESIS, QUESTION_MARK)) {
             const lookbehind =
-                this.ecmaVersion >= 2018 && this.eat(LessThanSign)
+                this.ecmaVersion >= 2018 && this.eat(LESS_THAN_SIGN)
             let negate = false
-            if (this.eat(EqualsSign) || (negate = this.eat(ExclamationMark))) {
+            if (
+                this.eat(EQUALS_SIGN) ||
+                (negate = this.eat(EXCLAMATION_MARK))
+            ) {
                 const kind = lookbehind ? "lookbehind" : "lookahead"
                 this.onLookaroundAssertionEnter(start, kind, negate)
                 this.consumeDisjunction()
-                if (!this.eat(RightParenthesis)) {
+                if (!this.eat(RIGHT_PARENTHESIS)) {
                     this.raise("Unterminated group")
                 }
                 this._lastAssertionIsQuantifiable = !lookbehind && !this.strict
@@ -1139,24 +1610,23 @@ export class RegExpValidator {
         let greedy = false
 
         // QuantifierPrefix
-        if (this.eat(Asterisk)) {
+        if (this.eat(ASTERISK)) {
             min = 0
             max = Number.POSITIVE_INFINITY
-        } else if (this.eat(PlusSign)) {
+        } else if (this.eat(PLUS_SIGN)) {
             min = 1
             max = Number.POSITIVE_INFINITY
-        } else if (this.eat(QuestionMark)) {
+        } else if (this.eat(QUESTION_MARK)) {
             min = 0
             max = 1
         } else if (this.eatBracedQuantifier(noConsume)) {
-            min = this._lastMinValue
-            max = this._lastMaxValue
+            ;({ min, max } = this._lastRange)
         } else {
             return false
         }
 
         // `?`
-        greedy = !this.eat(QuestionMark)
+        greedy = !this.eat(QUESTION_MARK)
 
         if (!noConsume) {
             this.onQuantifier(start, this.index, min, max, greedy)
@@ -1166,7 +1636,7 @@ export class RegExpValidator {
 
     /**
      * Eat the next characters as the following alternatives if possible.
-     * Set `this._lastMinValue` and `this._lastMaxValue` if it consumed the next
+     * Set `this._lastRange` if it consumed the next
      * characters successfully.
      * ```
      *      `{` DecimalDigits `}`
@@ -1177,24 +1647,24 @@ export class RegExpValidator {
      */
     private eatBracedQuantifier(noError: boolean): boolean {
         const start = this.index
-        if (this.eat(LeftCurlyBracket)) {
-            this._lastMinValue = 0
-            this._lastMaxValue = Number.POSITIVE_INFINITY
+        if (this.eat(LEFT_CURLY_BRACKET)) {
             if (this.eatDecimalDigits()) {
-                this._lastMinValue = this._lastMaxValue = this._lastIntValue
-                if (this.eat(Comma)) {
-                    this._lastMaxValue = this.eatDecimalDigits()
+                const min = this._lastIntValue
+                let max = min
+                if (this.eat(COMMA)) {
+                    max = this.eatDecimalDigits()
                         ? this._lastIntValue
                         : Number.POSITIVE_INFINITY
                 }
-                if (this.eat(RightCurlyBracket)) {
-                    if (!noError && this._lastMaxValue < this._lastMinValue) {
+                if (this.eat(RIGHT_CURLY_BRACKET)) {
+                    if (!noError && max < min) {
                         this.raise("numbers out of order in {} quantifier")
                     }
+                    this._lastRange = { min, max }
                     return true
                 }
             }
-            if (!noError && (this._uFlag || this.strict)) {
+            if (!noError && (this._unicodeMode || this.strict)) {
                 this.raise("Incomplete quantifier")
             }
             this.rewind(start)
@@ -1205,13 +1675,14 @@ export class RegExpValidator {
     /**
      * Validate the next characters as a RegExp `Atom` production if possible.
      * ```
-     * Atom[U, N]::
+     * Atom[UnicodeMode, UnicodeSetsMode, N]::
      *      PatternCharacter
      *      `.`
-     *      `\\` AtomEscape[?U, ?N]
-     *      CharacterClass[?U]
-     *      `(?:` Disjunction[?U, ?N] )
-     *      `(` GroupSpecifier[?U] Disjunction[?U, ?N] `)`
+     *      `\\` AtomEscape[?UnicodeMode, ?UnicodeSetsMode, ?N]
+     *      CharacterClass[?UnicodeMode, ?UnicodeSetsMode]
+     *      `(` GroupSpecifier[?UnicodeMode] Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?N] `)`
+     *      `(?` RegularExpressionFlags `:` Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?N] `)`
+     *      `(?` RegularExpressionFlags `-` RegularExpressionFlags `:` Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?N] `)`
      * ```
      * @returns `true` if it consumed the next characters successfully.
      */
@@ -1220,9 +1691,9 @@ export class RegExpValidator {
             this.consumePatternCharacter() ||
             this.consumeDot() ||
             this.consumeReverseSolidusAtomEscape() ||
-            this.consumeCharacterClass() ||
-            this.consumeUncapturingGroup() ||
-            this.consumeCapturingGroup()
+            Boolean(this.consumeCharacterClass()) ||
+            this.consumeCapturingGroup() ||
+            this.consumeUncapturingGroup()
         )
     }
 
@@ -1234,7 +1705,7 @@ export class RegExpValidator {
      * @returns `true` if it consumed the next characters successfully.
      */
     private consumeDot(): boolean {
-        if (this.eat(FullStop)) {
+        if (this.eat(FULL_STOP)) {
             this.onAnyCharacterSet(this.index - 1, this.index, "any")
             return true
         }
@@ -1244,13 +1715,13 @@ export class RegExpValidator {
     /**
      * Validate the next characters as the following alternatives if possible.
      * ```
-     *      `\\` AtomEscape[?U, ?N]
+     *      `\\` AtomEscape[?UnicodeMode, ?UnicodeSetsMode, ?N]
      * ```
      * @returns `true` if it consumed the next characters successfully.
      */
     private consumeReverseSolidusAtomEscape(): boolean {
         const start = this.index
-        if (this.eat(ReverseSolidus)) {
+        if (this.eat(REVERSE_SOLIDUS)) {
             if (this.consumeAtomEscape()) {
                 return true
             }
@@ -1262,16 +1733,28 @@ export class RegExpValidator {
     /**
      * Validate the next characters as the following alternatives if possible.
      * ```
-     *      `(?:` Disjunction[?U, ?N] )
+     *      `(?` RegularExpressionFlags `:` Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?N] `)`
+     *      `(?` RegularExpressionFlags `-` RegularExpressionFlags `:` Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?N] `)`
+     * RegularExpressionFlags ::
+     *      [empty]
+     *      RegularExpressionFlags IdentifierPartChar
      * ```
      * @returns `true` if it consumed the next characters successfully.
      */
     private consumeUncapturingGroup(): boolean {
         const start = this.index
-        if (this.eat3(LeftParenthesis, QuestionMark, Colon)) {
+        if (this.eat2(LEFT_PARENTHESIS, QUESTION_MARK)) {
             this.onGroupEnter(start)
+            if (this.ecmaVersion >= 2025) {
+                this.consumeModifiers()
+            }
+
+            if (!this.eat(COLON)) {
+                this.rewind(start + 1) // Throw an error at the question mark position.
+                this.raise("Invalid group")
+            }
             this.consumeDisjunction()
-            if (!this.eat(RightParenthesis)) {
+            if (!this.eat(RIGHT_PARENTHESIS)) {
                 this.raise("Unterminated group")
             }
             this.onGroupLeave(start, this.index)
@@ -1283,25 +1766,78 @@ export class RegExpValidator {
     /**
      * Validate the next characters as the following alternatives if possible.
      * ```
-     *      `(` GroupSpecifier[?U] Disjunction[?U, ?N] `)`
+     *      RegularExpressionFlags
+     *      RegularExpressionFlags `-` RegularExpressionFlags
+     * ```
+     */
+    private consumeModifiers(): boolean {
+        const start = this.index
+        const hasAddModifiers = this.eatModifiers()
+        const addModifiersEnd = this.index
+        const hasHyphen = this.eat(HYPHEN_MINUS)
+        if (!hasAddModifiers && !hasHyphen) {
+            return false
+        }
+        this.onModifiersEnter(start)
+        const addModifiers = this.parseModifiers(start, addModifiersEnd)
+        this.onAddModifiers(start, addModifiersEnd, addModifiers)
+
+        if (hasHyphen) {
+            const modifiersStart = this.index
+            if (
+                !this.eatModifiers() &&
+                !hasAddModifiers &&
+                this.currentCodePoint === COLON
+            ) {
+                this.raise("Invalid empty flags")
+            }
+            const modifiers = this.parseModifiers(modifiersStart, this.index)
+            for (const [flagName] of Object.entries(modifiers).filter(
+                ([, enable]) => enable,
+            ) as [keyof typeof modifiers, boolean][]) {
+                if (addModifiers[flagName]) {
+                    this.raise(
+                        `Duplicated flag '${String.fromCodePoint(
+                            FLAG_PROP_TO_CODEPOINT[flagName],
+                        )}'`,
+                    )
+                }
+            }
+            this.onRemoveModifiers(modifiersStart, this.index, modifiers)
+        }
+
+        this.onModifiersLeave(start, this.index)
+        return true
+    }
+
+    /**
+     * Validate the next characters as the following alternatives if possible.
+     * ```
+     *      `(` GroupSpecifier[?UnicodeMode] Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?N] `)`
      * ```
      * @returns `true` if it consumed the next characters successfully.
      */
     private consumeCapturingGroup(): boolean {
         const start = this.index
-        if (this.eat(LeftParenthesis)) {
+        if (this.eat(LEFT_PARENTHESIS)) {
             let name: string | null = null
             if (this.ecmaVersion >= 2018) {
                 if (this.consumeGroupSpecifier()) {
                     name = this._lastStrValue
+                } else if (this.currentCodePoint === QUESTION_MARK) {
+                    // Maybe Group with modifiers
+                    this.rewind(start)
+                    return false
                 }
-            } else if (this.currentCodePoint === QuestionMark) {
-                this.raise("Invalid group")
+            } else if (this.currentCodePoint === QUESTION_MARK) {
+                // Maybe Group with modifiers
+                this.rewind(start)
+                return false
             }
 
             this.onCapturingGroupEnter(start, name)
             this.consumeDisjunction()
-            if (!this.eat(RightParenthesis)) {
+            if (!this.eat(RIGHT_PARENTHESIS)) {
                 this.raise("Unterminated group")
             }
             this.onCapturingGroupLeave(start, this.index, name)
@@ -1320,8 +1856,9 @@ export class RegExpValidator {
      *      `\` AtomEscape[~U, ?N]
      *      `\` [lookahead = c]
      *      CharacterClass[~U]
-     *      `(?:` Disjunction[~U, ?N] `)`
      *      `(` Disjunction[~U, ?N] `)`
+     *      `(?` RegularExpressionFlags `:` Disjunction[?U, ?N] `)`
+     *      `(?` RegularExpressionFlags `-` RegularExpressionFlags `:` Disjunction[?U, ?N] `)`
      *      InvalidBracedQuantifier
      *      ExtendedPatternCharacter
      * ```
@@ -1332,9 +1869,9 @@ export class RegExpValidator {
             this.consumeDot() ||
             this.consumeReverseSolidusAtomEscape() ||
             this.consumeReverseSolidusFollowedByC() ||
-            this.consumeCharacterClass() ||
-            this.consumeUncapturingGroup() ||
+            Boolean(this.consumeCharacterClass()) ||
             this.consumeCapturingGroup() ||
+            this.consumeUncapturingGroup() ||
             this.consumeInvalidBracedQuantifier() ||
             this.consumeExtendedPatternCharacter()
         )
@@ -1350,12 +1887,12 @@ export class RegExpValidator {
     private consumeReverseSolidusFollowedByC(): boolean {
         const start = this.index
         if (
-            this.currentCodePoint === ReverseSolidus &&
-            this.nextCodePoint === LatinSmallLetterC
+            this.currentCodePoint === REVERSE_SOLIDUS &&
+            this.nextCodePoint === LATIN_SMALL_LETTER_C
         ) {
             this._lastIntValue = this.currentCodePoint
             this.advance()
-            this.onCharacter(start, this.index, ReverseSolidus)
+            this.onCharacter(start, this.index, REVERSE_SOLIDUS)
             return true
         }
         return false
@@ -1413,17 +1950,17 @@ export class RegExpValidator {
         const cp = this.currentCodePoint
         if (
             cp !== -1 &&
-            cp !== CircumflexAccent &&
-            cp !== DollarSign &&
-            cp !== ReverseSolidus &&
-            cp !== FullStop &&
-            cp !== Asterisk &&
-            cp !== PlusSign &&
-            cp !== QuestionMark &&
-            cp !== LeftParenthesis &&
-            cp !== RightParenthesis &&
-            cp !== LeftSquareBracket &&
-            cp !== VerticalLine
+            cp !== CIRCUMFLEX_ACCENT &&
+            cp !== DOLLAR_SIGN &&
+            cp !== REVERSE_SOLIDUS &&
+            cp !== FULL_STOP &&
+            cp !== ASTERISK &&
+            cp !== PLUS_SIGN &&
+            cp !== QUESTION_MARK &&
+            cp !== LEFT_PARENTHESIS &&
+            cp !== RIGHT_PARENTHESIS &&
+            cp !== LEFT_SQUARE_BRACKET &&
+            cp !== VERTICAL_LINE
         ) {
             this.advance()
             this.onCharacter(start, this.index, cp)
@@ -1436,22 +1973,24 @@ export class RegExpValidator {
      * Validate the next characters as a RegExp `GroupSpecifier` production.
      * Set `this._lastStrValue` if the group name existed.
      * ```
-     * GroupSpecifier[U]::
-     *      ε
-     *      `?` GroupName[?U]
+     * GroupSpecifier[UnicodeMode]::
+     *      [empty]
+     *      `?` GroupName[?UnicodeMode]
      * ```
      * @returns `true` if the group name existed.
      */
     private consumeGroupSpecifier(): boolean {
-        if (this.eat(QuestionMark)) {
+        const start = this.index
+        if (this.eat(QUESTION_MARK)) {
             if (this.eatGroupName()) {
-                if (!this._groupNames.has(this._lastStrValue)) {
-                    this._groupNames.add(this._lastStrValue)
+                if (!this._groupSpecifiers.hasInScope(this._lastStrValue)) {
+                    this._groupSpecifiers.addToScope(this._lastStrValue)
                     return true
                 }
                 this.raise("Duplicate capture group name")
             }
-            this.raise("Invalid group")
+            // Maybe Group with modifiers
+            this.rewind(start)
         }
         return false
     }
@@ -1460,14 +1999,14 @@ export class RegExpValidator {
      * Validate the next characters as a RegExp `AtomEscape` production if
      * possible.
      * ```
-     * AtomEscape[U, N]::
+     * AtomEscape[UnicodeMode, N]::
      *      [strict] DecimalEscape
-     *      [annexB][+U] DecimalEscape
-     *      [annexB][~U] DecimalEscape but only if the CapturingGroupNumber of DecimalEscape is <= NcapturingParens
-     *      CharacterClassEscape[?U]
-     *      [strict] CharacterEscape[?U]
-     *      [annexB] CharacterEscape[?U, ?N]
-     *      [+N] `k` GroupName[?U]
+     *      [annexB][+UnicodeMode] DecimalEscape
+     *      [annexB][~UnicodeMode] DecimalEscape but only if the CapturingGroupNumber of DecimalEscape is <= NcapturingParens
+     *      CharacterClassEscape[?UnicodeMode]
+     *      [strict] CharacterEscape[?UnicodeMode]
+     *      [annexB] CharacterEscape[?UnicodeMode, ?N]
+     *      [+N] `k` GroupName[?UnicodeMode]
      * ```
      * @returns `true` if it consumed the next characters successfully.
      */
@@ -1480,18 +2019,18 @@ export class RegExpValidator {
         ) {
             return true
         }
-        if (this.strict || this._uFlag) {
+        if (this.strict || this._unicodeMode) {
             this.raise("Invalid escape")
         }
         return false
     }
 
     /**
-     * Validate the next characters as the follwoing alternatives if possible.
+     * Validate the next characters as the following alternatives if possible.
      * ```
      *      [strict] DecimalEscape
-     *      [annexB][+U] DecimalEscape
-     *      [annexB][~U] DecimalEscape but only if the CapturingGroupNumber of DecimalEscape is <= NcapturingParens
+     *      [annexB][+UnicodeMode] DecimalEscape
+     *      [annexB][~UnicodeMode] DecimalEscape but only if the CapturingGroupNumber of DecimalEscape is <= NcapturingParens
      * ```
      * @returns `true` if it consumed the next characters successfully.
      */
@@ -1503,7 +2042,7 @@ export class RegExpValidator {
                 this.onBackreference(start - 1, this.index, n)
                 return true
             }
-            if (this.strict || this._uFlag) {
+            if (this.strict || this._unicodeMode) {
                 this.raise("Invalid escape")
             }
             this.rewind(start)
@@ -1517,93 +2056,145 @@ export class RegExpValidator {
      * Set `-1` to `this._lastIntValue` as meaning of a character set if it ate
      * the next characters successfully.
      * ```
-     * CharacterClassEscape[U]::
+     * CharacterClassEscape[UnicodeMode]::
      *      `d`
      *      `D`
      *      `s`
      *      `S`
      *      `w`
      *      `W`
-     *      [+U] `p{` UnicodePropertyValueExpression `}`
-     *      [+U] `P{` UnicodePropertyValueExpression `}`
+     *      [+UnicodeMode] `p{` UnicodePropertyValueExpression `}`
+     *      [+UnicodeMode] `P{` UnicodePropertyValueExpression `}`
      * ```
-     * @returns `true` if it consumed the next characters successfully.
+     * @returns the object if it consumed the next characters successfully.
      */
-    private consumeCharacterClassEscape(): boolean {
+    // eslint-disable-next-line complexity
+    private consumeCharacterClassEscape(): UnicodeSetsConsumeResult | null {
         const start = this.index
 
-        if (this.eat(LatinSmallLetterD)) {
+        if (this.eat(LATIN_SMALL_LETTER_D)) {
             this._lastIntValue = -1
             this.onEscapeCharacterSet(start - 1, this.index, "digit", false)
-            return true
+
+            // * Static Semantics: MayContainStrings
+            // CharacterClassEscape[UnicodeMode] ::
+            //         d
+            //     1. Return false.
+            return {}
         }
-        if (this.eat(LatinCapitalLetterD)) {
+        if (this.eat(LATIN_CAPITAL_LETTER_D)) {
             this._lastIntValue = -1
             this.onEscapeCharacterSet(start - 1, this.index, "digit", true)
-            return true
+
+            // * Static Semantics: MayContainStrings
+            // CharacterClassEscape[UnicodeMode] ::
+            //         D
+            //     1. Return false.
+            return {}
         }
-        if (this.eat(LatinSmallLetterS)) {
+        if (this.eat(LATIN_SMALL_LETTER_S)) {
             this._lastIntValue = -1
             this.onEscapeCharacterSet(start - 1, this.index, "space", false)
-            return true
+
+            // * Static Semantics: MayContainStrings
+            // CharacterClassEscape[UnicodeMode] ::
+            //         s
+            //     1. Return false.
+            return {}
         }
-        if (this.eat(LatinCapitalLetterS)) {
+        if (this.eat(LATIN_CAPITAL_LETTER_S)) {
             this._lastIntValue = -1
             this.onEscapeCharacterSet(start - 1, this.index, "space", true)
-            return true
+
+            // * Static Semantics: MayContainStrings
+            // CharacterClassEscape[UnicodeMode] ::
+            //         S
+            //     1. Return false.
+            return {}
         }
-        if (this.eat(LatinSmallLetterW)) {
+        if (this.eat(LATIN_SMALL_LETTER_W)) {
             this._lastIntValue = -1
             this.onEscapeCharacterSet(start - 1, this.index, "word", false)
-            return true
+
+            // * Static Semantics: MayContainStrings
+            // CharacterClassEscape[UnicodeMode] ::
+            //         w
+            //     1. Return false.
+            return {}
         }
-        if (this.eat(LatinCapitalLetterW)) {
+        if (this.eat(LATIN_CAPITAL_LETTER_W)) {
             this._lastIntValue = -1
             this.onEscapeCharacterSet(start - 1, this.index, "word", true)
-            return true
+
+            // * Static Semantics: MayContainStrings
+            // CharacterClassEscape[UnicodeMode] ::
+            //         W
+            //     1. Return false.
+            return {}
         }
 
         let negate = false
         if (
-            this._uFlag &&
+            this._unicodeMode &&
             this.ecmaVersion >= 2018 &&
-            (this.eat(LatinSmallLetterP) ||
-                (negate = this.eat(LatinCapitalLetterP)))
+            (this.eat(LATIN_SMALL_LETTER_P) ||
+                (negate = this.eat(LATIN_CAPITAL_LETTER_P)))
         ) {
             this._lastIntValue = -1
+            let result: UnicodePropertyValueExpressionConsumeResult | null =
+                null
             if (
-                this.eat(LeftCurlyBracket) &&
-                this.eatUnicodePropertyValueExpression() &&
-                this.eat(RightCurlyBracket)
+                this.eat(LEFT_CURLY_BRACKET) &&
+                (result = this.eatUnicodePropertyValueExpression()) &&
+                this.eat(RIGHT_CURLY_BRACKET)
             ) {
+                if (negate && result.strings) {
+                    this.raise("Invalid property name")
+                }
+
                 this.onUnicodePropertyCharacterSet(
                     start - 1,
                     this.index,
                     "property",
-                    this._lastKeyValue,
-                    this._lastValValue || null,
+                    result.key,
+                    result.value,
                     negate,
+                    result.strings ?? false,
                 )
-                return true
+
+                // * Static Semantics: MayContainStrings
+                // CharacterClassEscape[UnicodeMode] ::
+                //         P{ UnicodePropertyValueExpression }
+                // UnicodePropertyValueExpression ::
+                //         UnicodePropertyName = UnicodePropertyValue
+                //     1. Return false.
+                // CharacterClassEscape :: p{ UnicodePropertyValueExpression }
+                //     1. Return MayContainStrings of the UnicodePropertyValueExpression.
+                // UnicodePropertyValueExpression :: LoneUnicodePropertyNameOrValue
+                //     1. If SourceText of LoneUnicodePropertyNameOrValue is identical to a List of Unicode code points that is a binary property of strings listed in the “Property name” column of Table 69, return true.
+                //     2. Return false.
+                //
+                // negate==true && mayContainStrings==true is already errors, so no need to handle it.
+                return { mayContainStrings: result.strings }
             }
             this.raise("Invalid property name")
         }
 
-        return false
+        return null
     }
 
     /**
      * Validate the next characters as a RegExp `CharacterEscape` production if
      * possible.
      * ```
-     * CharacterEscape[U, N]::
+     * CharacterEscape[UnicodeMode, N]::
      *      ControlEscape
      *      `c` ControlLetter
      *      `0` [lookahead ∉ DecimalDigit]
      *      HexEscapeSequence
-     *      RegExpUnicodeEscapeSequence[?U]
-     *      [annexB][~U] LegacyOctalEscapeSequence
-     *      IdentityEscape[?U, ?N]
+     *      RegExpUnicodeEscapeSequence[?UnicodeMode]
+     *      [annexB][~UnicodeMode] LegacyOctalEscapeSequence
+     *      IdentityEscape[?UnicodeMode, ?N]
      * ```
      * @returns `true` if it consumed the next characters successfully.
      */
@@ -1616,7 +2207,7 @@ export class RegExpValidator {
             this.eatHexEscapeSequence() ||
             this.eatRegExpUnicodeEscapeSequence() ||
             (!this.strict &&
-                !this._uFlag &&
+                !this._unicodeMode &&
                 this.eatLegacyOctalEscapeSequence()) ||
             this.eatIdentityEscape()
         ) {
@@ -1627,15 +2218,15 @@ export class RegExpValidator {
     }
 
     /**
-     * Validate the next characters as the follwoing alternatives if possible.
+     * Validate the next characters as the following alternatives if possible.
      * ```
-     *      `k` GroupName[?U]
+     *      `k` GroupName[?UnicodeMode]
      * ```
      * @returns `true` if it consumed the next characters successfully.
      */
     private consumeKGroupName(): boolean {
         const start = this.index
-        if (this.eat(LatinSmallLetterK)) {
+        if (this.eat(LATIN_SMALL_LETTER_K)) {
             if (this.eatGroupName()) {
                 const groupName = this._lastStrValue
                 this._backreferenceNames.add(groupName)
@@ -1651,45 +2242,77 @@ export class RegExpValidator {
      * Validate the next characters as a RegExp `CharacterClass` production if
      * possible.
      * ```
-     * CharacterClass[U]::
-     *      `[` [lookahead ≠ ^] ClassRanges[?U] `]`
-     *      `[^` ClassRanges[?U] `]`
+     * CharacterClass[UnicodeMode, UnicodeSetsMode]::
+     *      `[` [lookahead ≠ ^] ClassContents[?UnicodeMode, ?UnicodeSetsMode] `]`
+     *      `[^` ClassContents[?UnicodeMode, ?UnicodeSetsMode] `]`
      * ```
-     * @returns `true` if it consumed the next characters successfully.
+     * @returns the object if it consumed the next characters successfully.
      */
-    private consumeCharacterClass(): boolean {
+    private consumeCharacterClass(): UnicodeSetsConsumeResult | null {
         const start = this.index
-        if (this.eat(LeftSquareBracket)) {
-            const negate = this.eat(CircumflexAccent)
-            this.onCharacterClassEnter(start, negate)
-            this.consumeClassRanges()
-            if (!this.eat(RightSquareBracket)) {
-                this.raise("Unterminated character class")
+        if (this.eat(LEFT_SQUARE_BRACKET)) {
+            const negate = this.eat(CIRCUMFLEX_ACCENT)
+            this.onCharacterClassEnter(start, negate, this._unicodeSetsMode)
+            const result = this.consumeClassContents()
+            if (!this.eat(RIGHT_SQUARE_BRACKET)) {
+                if (this.currentCodePoint === -1) {
+                    this.raise("Unterminated character class")
+                }
+                this.raise("Invalid character in character class")
+            }
+            if (negate && result.mayContainStrings) {
+                this.raise("Negated character class may contain strings")
             }
+
             this.onCharacterClassLeave(start, this.index, negate)
-            return true
+
+            // * Static Semantics: MayContainStrings
+            // CharacterClass[UnicodeMode, UnicodeSetsMode] ::
+            //         [ ^ ClassContents[?UnicodeMode, ?UnicodeSetsMode] ]
+            //     1. Return false.
+            // CharacterClass :: [ ClassContents ]
+            //     1. Return MayContainStrings of the ClassContents.
+            return result
         }
-        return false
+        return null
     }
 
     /**
-     * Validate the next characters as a RegExp `ClassRanges` production.
-     * ```
-     * ClassRanges[U]::
-     *      ε
-     *      NonemptyClassRanges[?U]
-     * NonemptyClassRanges[U]::
-     *      ClassAtom[?U]
-     *      ClassAtom[?U] NonemptyClassRangesNoDash[?U]
-     *      ClassAtom[?U] `-` ClassAtom[?U] ClassRanges[?U]
-     * NonemptyClassRangesNoDash[U]::
-     *      ClassAtom[?U]
-     *      ClassAtomNoDash[?U] NonemptyClassRangesNoDash[?U]
-     *      ClassAtomNoDash[?U] `-` ClassAtom[?U] ClassRanges[?U]
+     * Validate the next characters as a RegExp `ClassContents` production.
+     * ```
+     * ClassContents[UnicodeMode, UnicodeSetsMode] ::
+     *      [empty]
+     *      [~UnicodeSetsMode] NonemptyClassRanges[?UnicodeMode]
+     *      [+UnicodeSetsMode] ClassSetExpression
+     * NonemptyClassRanges[UnicodeMode]::
+     *      ClassAtom[?UnicodeMode]
+     *      ClassAtom[?UnicodeMode] NonemptyClassRangesNoDash[?UnicodeMode]
+     *      ClassAtom[?UnicodeMode] `-` ClassAtom[?UnicodeMode] ClassContents[?UnicodeMode, ~UnicodeSetsMode]
+     * NonemptyClassRangesNoDash[UnicodeMode]::
+     *      ClassAtom[?UnicodeMode]
+     *      ClassAtomNoDash[?UnicodeMode] NonemptyClassRangesNoDash[?UnicodeMode]
+     *      ClassAtomNoDash[?UnicodeMode] `-` ClassAtom[?UnicodeMode] ClassContents[?UnicodeMode, ~UnicodeSetsMode]
      * ```
      */
-    private consumeClassRanges(): void {
-        const strict = this.strict || this._uFlag
+    private consumeClassContents(): UnicodeSetsConsumeResult {
+        if (this._unicodeSetsMode) {
+            if (this.currentCodePoint === RIGHT_SQUARE_BRACKET) {
+                // [empty]
+
+                // * Static Semantics: MayContainStrings
+                // ClassContents[UnicodeMode, UnicodeSetsMode] ::
+                //         [empty]
+                //     1. Return false.
+                return {}
+            }
+            const result = this.consumeClassSetExpression()
+
+            // * Static Semantics: MayContainStrings
+            // ClassContents :: ClassSetExpression
+            //     1. Return MayContainStrings of the ClassSetExpression.
+            return result
+        }
+        const strict = this.strict || this._unicodeMode
         for (;;) {
             // Consume the first ClassAtom
             const rangeStart = this.index
@@ -1699,10 +2322,10 @@ export class RegExpValidator {
             const min = this._lastIntValue
 
             // Consume `-`
-            if (!this.eat(HyphenMinus)) {
+            if (!this.eat(HYPHEN_MINUS)) {
                 continue
             }
-            this.onCharacter(this.index - 1, this.index, HyphenMinus)
+            this.onCharacter(this.index - 1, this.index, HYPHEN_MINUS)
 
             // Consume the second ClassAtom
             if (!this.consumeClassAtom()) {
@@ -1723,6 +2346,12 @@ export class RegExpValidator {
 
             this.onCharacterClassRange(rangeStart, this.index, min, max)
         }
+
+        // * Static Semantics: MayContainStrings
+        // ClassContents[UnicodeMode, UnicodeSetsMode] ::
+        //         NonemptyClassRanges[?UnicodeMode]
+        //     1. Return false.
+        return {}
     }
 
     /**
@@ -1730,12 +2359,12 @@ export class RegExpValidator {
      * possible.
      * Set `this._lastIntValue` if it consumed the next characters successfully.
      * ```
-     * ClassAtom[U, N]::
+     * ClassAtom[UnicodeMode, N]::
      *      `-`
-     *      ClassAtomNoDash[?U, ?N]
-     * ClassAtomNoDash[U, N]::
+     *      ClassAtomNoDash[?UnicodeMode, ?N]
+     * ClassAtomNoDash[UnicodeMode, N]::
      *      SourceCharacter but not one of \ ] -
-     *      `\` ClassEscape[?U, ?N]
+     *      `\` ClassEscape[?UnicodeMode, ?N]
      *      [annexB] `\` [lookahead = c]
      * ```
      * @returns `true` if it consumed the next characters successfully.
@@ -1744,23 +2373,30 @@ export class RegExpValidator {
         const start = this.index
         const cp = this.currentCodePoint
 
-        if (cp !== -1 && cp !== ReverseSolidus && cp !== RightSquareBracket) {
+        if (
+            cp !== -1 &&
+            cp !== REVERSE_SOLIDUS &&
+            cp !== RIGHT_SQUARE_BRACKET
+        ) {
             this.advance()
             this._lastIntValue = cp
             this.onCharacter(start, this.index, this._lastIntValue)
             return true
         }
 
-        if (this.eat(ReverseSolidus)) {
+        if (this.eat(REVERSE_SOLIDUS)) {
             if (this.consumeClassEscape()) {
                 return true
             }
-            if (!this.strict && this.currentCodePoint === LatinSmallLetterC) {
-                this._lastIntValue = ReverseSolidus
+            if (
+                !this.strict &&
+                this.currentCodePoint === LATIN_SMALL_LETTER_C
+            ) {
+                this._lastIntValue = REVERSE_SOLIDUS
                 this.onCharacter(start, this.index, this._lastIntValue)
                 return true
             }
-            if (this.strict || this._uFlag) {
+            if (this.strict || this._unicodeMode) {
                 this.raise("Invalid escape")
             }
             this.rewind(start)
@@ -1774,12 +2410,12 @@ export class RegExpValidator {
      * possible.
      * Set `this._lastIntValue` if it consumed the next characters successfully.
      * ```
-     * ClassEscape[U, N]::
+     * ClassEscape[UnicodeMode, N]::
      *      `b`
-     *      [+U] `-`
-     *      [annexB][~U] `c` ClassControlLetter
-     *      CharacterClassEscape[?U]
-     *      CharacterEscape[?U, ?N]
+     *      [+UnicodeMode] `-`
+     *      [annexB][~UnicodeMode] `c` ClassControlLetter
+     *      CharacterClassEscape[?UnicodeMode]
+     *      CharacterEscape[?UnicodeMode, ?N]
      * ClassControlLetter::
      *      DecimalDigit
      *      `_`
@@ -1790,26 +2426,26 @@ export class RegExpValidator {
         const start = this.index
 
         // `b`
-        if (this.eat(LatinSmallLetterB)) {
-            this._lastIntValue = Backspace
+        if (this.eat(LATIN_SMALL_LETTER_B)) {
+            this._lastIntValue = BACKSPACE
             this.onCharacter(start - 1, this.index, this._lastIntValue)
             return true
         }
 
-        // [+U] `-`
-        if (this._uFlag && this.eat(HyphenMinus)) {
-            this._lastIntValue = HyphenMinus
+        // [+UnicodeMode] `-`
+        if (this._unicodeMode && this.eat(HYPHEN_MINUS)) {
+            this._lastIntValue = HYPHEN_MINUS
             this.onCharacter(start - 1, this.index, this._lastIntValue)
             return true
         }
 
-        // [annexB][~U] `c` ClassControlLetter
+        // [annexB][~UnicodeMode] `c` ClassControlLetter
         let cp = 0
         if (
             !this.strict &&
-            !this._uFlag &&
-            this.currentCodePoint === LatinSmallLetterC &&
-            (isDecimalDigit((cp = this.nextCodePoint)) || cp === LowLine)
+            !this._unicodeMode &&
+            this.currentCodePoint === LATIN_SMALL_LETTER_C &&
+            (isDecimalDigit((cp = this.nextCodePoint)) || cp === LOW_LINE)
         ) {
             this.advance()
             this.advance()
@@ -1819,22 +2455,410 @@ export class RegExpValidator {
         }
 
         return (
-            this.consumeCharacterClassEscape() || this.consumeCharacterEscape()
+            Boolean(this.consumeCharacterClassEscape()) ||
+            this.consumeCharacterEscape()
         )
     }
 
+    /**
+     * Validate the next characters as a RegExp `ClassSetExpression` production.
+     * ```
+     * ClassSetExpression ::
+     *     ClassUnion
+     *     ClassIntersection
+     *     ClassSubtraction
+     * ClassUnion ::
+     *     ClassSetRange ClassUnion(opt)
+     *     ClassSetOperand ClassUnion(opt)
+     * ClassIntersection ::
+     *     ClassSetOperand `&&` [lookahead ≠ &] ClassSetOperand
+     *     ClassIntersection `&&` [lookahead ≠ &] ClassSetOperand
+     * ClassSubtraction ::
+     *     ClassSetOperand `--` ClassSetOperand
+     *     ClassSubtraction `--` ClassSetOperand
+     * ```
+     */
+    private consumeClassSetExpression(): UnicodeSetsConsumeResult {
+        const start = this.index
+        let mayContainStrings: boolean | undefined = false
+        let result: UnicodeSetsConsumeResult | null = null
+        if (this.consumeClassSetCharacter()) {
+            if (this.consumeClassSetRangeFromOperator(start)) {
+                // ClassUnion
+                this.consumeClassUnionRight({})
+                return {}
+            }
+            // ClassSetOperand
+
+            // * Static Semantics: MayContainStrings
+            // ClassSetOperand ::
+            //         ClassSetCharacter
+            //     1. Return false.
+            mayContainStrings = false
+        } else if ((result = this.consumeClassSetOperand())) {
+            mayContainStrings = result.mayContainStrings
+        } else {
+            const cp = this.currentCodePoint
+            if (cp === REVERSE_SOLIDUS) {
+                // Make the same message as V8.
+                this.advance()
+                this.raise("Invalid escape")
+            }
+            if (
+                cp === this.nextCodePoint &&
+                isClassSetReservedDoublePunctuatorCharacter(cp)
+            ) {
+                // Make the same message as V8.
+                this.raise("Invalid set operation in character class")
+            }
+            this.raise("Invalid character in character class")
+        }
+
+        if (this.eat2(AMPERSAND, AMPERSAND)) {
+            // ClassIntersection
+            while (
+                this.currentCodePoint !== AMPERSAND &&
+                (result = this.consumeClassSetOperand())
+            ) {
+                this.onClassIntersection(start, this.index)
+                if (!result.mayContainStrings) {
+                    mayContainStrings = false
+                }
+                if (this.eat2(AMPERSAND, AMPERSAND)) {
+                    continue
+                }
+
+                // * Static Semantics: MayContainStrings
+                // ClassSetExpression :: ClassIntersection
+                //     1. Return MayContainStrings of the ClassIntersection.
+                // ClassIntersection :: ClassSetOperand && ClassSetOperand
+                //     1. If MayContainStrings of the first ClassSetOperand is false, return false.
+                //     2. If MayContainStrings of the second ClassSetOperand is false, return false.
+                //     3. Return true.
+                // ClassIntersection :: ClassIntersection && ClassSetOperand
+                //     1. If MayContainStrings of the ClassIntersection is false, return false.
+                //     2. If MayContainStrings of the ClassSetOperand is false, return false.
+                //     3. Return true.
+                return { mayContainStrings }
+            }
+
+            this.raise("Invalid character in character class")
+        }
+        if (this.eat2(HYPHEN_MINUS, HYPHEN_MINUS)) {
+            // ClassSubtraction
+            while (this.consumeClassSetOperand()) {
+                this.onClassSubtraction(start, this.index)
+                if (this.eat2(HYPHEN_MINUS, HYPHEN_MINUS)) {
+                    continue
+                }
+                // * Static Semantics: MayContainStrings
+                // ClassSetExpression :: ClassSubtraction
+                //     1. Return MayContainStrings of the ClassSubtraction.
+                // ClassSubtraction :: ClassSetOperand -- ClassSetOperand
+                //     1. Return MayContainStrings of the first ClassSetOperand.
+                // ClassSubtraction :: ClassSubtraction -- ClassSetOperand
+                //     1. Return MayContainStrings of the ClassSubtraction.
+                return { mayContainStrings }
+            }
+            this.raise("Invalid character in character class")
+        }
+        // ClassUnion
+        return this.consumeClassUnionRight({ mayContainStrings })
+    }
+
+    /**
+     * Validate the next characters as right operand of a RegExp `ClassUnion` production.
+     * ```
+     * ClassUnion ::
+     *     ClassSetRange ClassUnion(opt)
+     *     ClassSetOperand ClassUnion(opt)
+     * ```
+     * @param leftResult The result information for the left `ClassSetRange` or `ClassSetOperand`.
+     */
+    private consumeClassUnionRight(
+        leftResult: UnicodeSetsConsumeResult,
+    ): UnicodeSetsConsumeResult {
+        // ClassUnion
+        let mayContainStrings = leftResult.mayContainStrings
+        for (;;) {
+            const start = this.index
+            if (this.consumeClassSetCharacter()) {
+                this.consumeClassSetRangeFromOperator(start)
+                continue
+            }
+            const result = this.consumeClassSetOperand()
+            if (result) {
+                if (result.mayContainStrings) {
+                    mayContainStrings = true
+                }
+                continue
+            }
+            break
+        }
+
+        // * Static Semantics: MayContainStrings
+        // ClassSetExpression :: ClassUnion
+        //     1. Return MayContainStrings of the ClassUnion.
+        // ClassUnion :: ClassSetRange ClassUnion(opt)
+        //     1. If the ClassUnion is present, return MayContainStrings of the ClassUnion.
+        //     2. Return false.
+        // ClassUnion :: ClassSetOperand ClassUnion(opt)
+        //     1. If MayContainStrings of the ClassSetOperand is true, return true.
+        //     2. If ClassUnion is present, return MayContainStrings of the ClassUnion.
+        //     3. Return false.
+        return { mayContainStrings }
+    }
+
+    /**
+     * Validate the next characters as from the `-` operator in a RegExp `ClassSetRange` production if possible.
+     *
+     * ```
+     * ClassSetRange ::
+     *     ClassSetCharacter `-` ClassSetCharacter
+     * ```
+     *
+     * @param start The starting position of the left operand.
+     * @returns `true` if it consumed the next characters successfully.
+     */
+    private consumeClassSetRangeFromOperator(start: number) {
+        const currentStart = this.index
+        const min = this._lastIntValue
+        if (this.eat(HYPHEN_MINUS)) {
+            if (this.consumeClassSetCharacter()) {
+                const max = this._lastIntValue
+
+                // Validate
+                if (min === -1 || max === -1) {
+                    this.raise("Invalid character class")
+                }
+                if (min > max) {
+                    this.raise("Range out of order in character class")
+                }
+                this.onCharacterClassRange(start, this.index, min, max)
+                return true
+            }
+            this.rewind(currentStart)
+        }
+        return false
+    }
+
+    /**
+     * Validate the next characters as a RegExp `ClassSetOperand` production if possible.
+     * ```
+     * ClassSetOperand ::
+     *     ClassSetCharacter
+     *     ClassStringDisjunction
+     *     NestedClass
+     * ```
+     *
+     * @returns the object if it consumed the next characters successfully.
+     */
+    private consumeClassSetOperand(): UnicodeSetsConsumeResult | null {
+        let result: UnicodeSetsConsumeResult | null = null
+        if ((result = this.consumeNestedClass())) {
+            // * Static Semantics: MayContainStrings
+            // ClassSetOperand :: NestedClass
+            //     1. Return MayContainStrings of the NestedClass.
+            return result
+        }
+        if ((result = this.consumeClassStringDisjunction())) {
+            // * Static Semantics: MayContainStrings
+            // ClassSetOperand :: ClassStringDisjunction
+            //     1. Return MayContainStrings of the ClassStringDisjunction.
+            return result
+        }
+        if (this.consumeClassSetCharacter()) {
+            // * Static Semantics: MayContainStrings
+            // ClassSetOperand ::
+            //         ClassSetCharacter
+            //     1. Return false.
+            return {}
+        }
+        return null
+    }
+
+    /**
+     * Validate the next characters as a RegExp `NestedClass` production if possible.
+     * ```
+     * NestedClass ::
+     *     `[` [lookahead ≠ ^] ClassContents[+UnicodeMode, +UnicodeSetsMode] `]`
+     *     `[^` ClassContents[+UnicodeMode, +UnicodeSetsMode] `]`
+     *     `\` CharacterClassEscape[+UnicodeMode]
+     * ```
+     * @returns the object if it consumed the next characters successfully.
+     */
+    private consumeNestedClass(): UnicodeSetsConsumeResult | null {
+        const start = this.index
+        if (this.eat(LEFT_SQUARE_BRACKET)) {
+            const negate = this.eat(CIRCUMFLEX_ACCENT)
+            this.onCharacterClassEnter(start, negate, true)
+            const result = this.consumeClassContents()
+            if (!this.eat(RIGHT_SQUARE_BRACKET)) {
+                this.raise("Unterminated character class")
+            }
+            if (negate && result.mayContainStrings) {
+                this.raise("Negated character class may contain strings")
+            }
+            this.onCharacterClassLeave(start, this.index, negate)
+
+            // * Static Semantics: MayContainStrings
+            // NestedClass ::
+            //         [ ^ ClassContents[+UnicodeMode, +UnicodeSetsMode] ]
+            //     1. Return false.
+            // NestedClass :: [ ClassContents ]
+            //     1. Return MayContainStrings of the ClassContents.
+            return result
+        }
+        if (this.eat(REVERSE_SOLIDUS)) {
+            const result = this.consumeCharacterClassEscape()
+            if (result) {
+                // * Static Semantics: MayContainStrings
+                // NestedClass :: \ CharacterClassEscape
+                //     1. Return MayContainStrings of the CharacterClassEscape.
+                return result
+            }
+            this.rewind(start)
+        }
+        return null
+    }
+
+    /**
+     * Validate the next characters as a RegExp `ClassStringDisjunction` production if possible.
+     * ```
+     * ClassStringDisjunction ::
+     *     `\q{` ClassStringDisjunctionContents `}`
+     * ClassStringDisjunctionContents ::
+     *     ClassString
+     *     ClassString `|` ClassStringDisjunctionContents
+     * ```
+     * @returns the object if it consumed the next characters successfully.
+     */
+    private consumeClassStringDisjunction(): UnicodeSetsConsumeResult | null {
+        const start = this.index
+        if (
+            this.eat3(REVERSE_SOLIDUS, LATIN_SMALL_LETTER_Q, LEFT_CURLY_BRACKET)
+        ) {
+            this.onClassStringDisjunctionEnter(start)
+
+            let i = 0
+            let mayContainStrings = false
+            do {
+                if (this.consumeClassString(i++).mayContainStrings) {
+                    mayContainStrings = true
+                }
+            } while (this.eat(VERTICAL_LINE))
+
+            if (this.eat(RIGHT_CURLY_BRACKET)) {
+                this.onClassStringDisjunctionLeave(start, this.index)
+
+                // * Static Semantics: MayContainStrings
+                // ClassStringDisjunction :: \q{ ClassStringDisjunctionContents }
+                //     1. Return MayContainStrings of the ClassStringDisjunctionContents.
+                // ClassStringDisjunctionContents :: ClassString
+                //     1. Return MayContainStrings of the ClassString.
+                // ClassStringDisjunctionContents :: ClassString | ClassStringDisjunctionContents
+                //     1. If MayContainStrings of the ClassString is true, return true.
+                //     2. Return MayContainStrings of the ClassStringDisjunctionContents.
+                return { mayContainStrings }
+            }
+            this.raise("Unterminated class string disjunction")
+        }
+        return null
+    }
+
+    /**
+     * Validate the next characters as a RegExp `ClassString ` production.
+     * ```
+     * ClassString ::
+     *     [empty]
+     *     NonEmptyClassString
+     * NonEmptyClassString ::
+     *     ClassSetCharacter NonEmptyClassString(opt)
+     * ```
+     */
+    private consumeClassString(i: number): UnicodeSetsConsumeResult {
+        const start = this.index
+
+        let count = 0
+        this.onStringAlternativeEnter(start, i)
+        while (
+            this.currentCodePoint !== -1 &&
+            this.consumeClassSetCharacter()
+        ) {
+            count++
+        }
+        this.onStringAlternativeLeave(start, this.index, i)
+
+        // * Static Semantics: MayContainStrings
+        // ClassString :: [empty]
+        //     1. Return true.
+        // ClassString :: NonEmptyClassString
+        //     1. Return MayContainStrings of the NonEmptyClassString.
+        // NonEmptyClassString :: ClassSetCharacter NonEmptyClassString(opt)
+        //     1. If NonEmptyClassString is present, return true.
+        //     2. Return false.
+        return { mayContainStrings: count !== 1 }
+    }
+
+    /**
+     * Validate the next characters as a RegExp `ClassSetCharacter` production if possible.
+     * Set `this._lastIntValue` if it consumed the next characters successfully.
+     * ```
+     * ClassSetCharacter ::
+     *     [lookahead ∉ ClassSetReservedDoublePunctuator] SourceCharacter but not ClassSetSyntaxCharacter
+     *     `\` CharacterEscape[+UnicodeMode]
+     *     `\` ClassSetReservedPunctuator
+     *     `\b`
+     * ```
+     * @returns `true` if it ate the next characters successfully.
+     */
+    private consumeClassSetCharacter(): boolean {
+        const start = this.index
+        const cp = this.currentCodePoint
+        if (
+            // [lookahead ∉ ClassSetReservedDoublePunctuator]
+            cp !== this.nextCodePoint ||
+            !isClassSetReservedDoublePunctuatorCharacter(cp)
+        ) {
+            if (cp !== -1 && !isClassSetSyntaxCharacter(cp)) {
+                this._lastIntValue = cp
+                this.advance()
+                this.onCharacter(start, this.index, this._lastIntValue)
+                return true
+            }
+        }
+        if (this.eat(REVERSE_SOLIDUS)) {
+            if (this.consumeCharacterEscape()) {
+                return true
+            }
+            if (isClassSetReservedPunctuator(this.currentCodePoint)) {
+                this._lastIntValue = this.currentCodePoint
+                this.advance()
+                this.onCharacter(start, this.index, this._lastIntValue)
+                return true
+            }
+            if (this.eat(LATIN_SMALL_LETTER_B)) {
+                this._lastIntValue = BACKSPACE
+                this.onCharacter(start, this.index, this._lastIntValue)
+                return true
+            }
+            this.rewind(start)
+        }
+        return false
+    }
+
     /**
      * Eat the next characters as a RegExp `GroupName` production if possible.
      * Set `this._lastStrValue` if the group name existed.
      * ```
-     * GroupName[U]::
-     *      `<` RegExpIdentifierName[?U] `>`
+     * GroupName[UnicodeMode]::
+     *      `<` RegExpIdentifierName[?UnicodeMode] `>`
      * ```
      * @returns `true` if it ate the next characters successfully.
      */
     private eatGroupName(): boolean {
-        if (this.eat(LessThanSign)) {
-            if (this.eatRegExpIdentifierName() && this.eat(GreaterThanSign)) {
+        if (this.eat(LESS_THAN_SIGN)) {
+            if (this.eatRegExpIdentifierName() && this.eat(GREATER_THAN_SIGN)) {
                 return true
             }
             this.raise("Invalid capture group name")
@@ -1847,9 +2871,9 @@ export class RegExpValidator {
      * possible.
      * Set `this._lastStrValue` if the identifier name existed.
      * ```
-     * RegExpIdentifierName[U]::
-     *      RegExpIdentifierStart[?U]
-     *      RegExpIdentifierName[?U] RegExpIdentifierPart[?U]
+     * RegExpIdentifierName[UnicodeMode]::
+     *      RegExpIdentifierStart[?UnicodeMode]
+     *      RegExpIdentifierName[?UnicodeMode] RegExpIdentifierPart[?UnicodeMode]
      * ```
      * @returns `true` if it ate the next characters successfully.
      */
@@ -1869,23 +2893,23 @@ export class RegExpValidator {
      * possible.
      * Set `this._lastIntValue` if the identifier start existed.
      * ```
-     * RegExpIdentifierStart[U] ::
-     *      UnicodeIDStart
+     * RegExpIdentifierStart[UnicodeMode] ::
+     *      IdentifierStartChar
      *      `$`
      *      `_`
-     *      `\` RegExpUnicodeEscapeSequence[+U]
-     *      [~U] UnicodeLeadSurrogate UnicodeTrailSurrogate
+     *      `\` RegExpUnicodeEscapeSequence[+UnicodeMode]
+     *      [~UnicodeMode] UnicodeLeadSurrogate UnicodeTrailSurrogate
      * ```
      * @returns `true` if it ate the next characters successfully.
      */
     private eatRegExpIdentifierStart(): boolean {
         const start = this.index
-        const forceUFlag = !this._uFlag && this.ecmaVersion >= 2020
+        const forceUFlag = !this._unicodeMode && this.ecmaVersion >= 2020
         let cp = this.currentCodePoint
         this.advance()
 
         if (
-            cp === ReverseSolidus &&
+            cp === REVERSE_SOLIDUS &&
             this.eatRegExpUnicodeEscapeSequence(forceUFlag)
         ) {
             cp = this._lastIntValue
@@ -1898,7 +2922,7 @@ export class RegExpValidator {
             this.advance()
         }
 
-        if (isRegExpIdentifierStart(cp)) {
+        if (isIdentifierStartChar(cp)) {
             this._lastIntValue = cp
             return true
         }
@@ -1914,25 +2938,21 @@ export class RegExpValidator {
      * possible.
      * Set `this._lastIntValue` if the identifier part existed.
      * ```
-     * RegExpIdentifierPart[U] ::
-     *      UnicodeIDContinue
-     *      `$`
-     *      `_`
-     *      `\` RegExpUnicodeEscapeSequence[+U]
-     *      [~U] UnicodeLeadSurrogate UnicodeTrailSurrogate
-     *      <ZWNJ>
-     *      <ZWJ>
+     * RegExpIdentifierPart[UnicodeMode] ::
+     *      IdentifierPartChar
+     *      `\` RegExpUnicodeEscapeSequence[+UnicodeMode]
+     *      [~UnicodeMode] UnicodeLeadSurrogate UnicodeTrailSurrogate
      * ```
      * @returns `true` if it ate the next characters successfully.
      */
     private eatRegExpIdentifierPart(): boolean {
         const start = this.index
-        const forceUFlag = !this._uFlag && this.ecmaVersion >= 2020
+        const forceUFlag = !this._unicodeMode && this.ecmaVersion >= 2020
         let cp = this.currentCodePoint
         this.advance()
 
         if (
-            cp === ReverseSolidus &&
+            cp === REVERSE_SOLIDUS &&
             this.eatRegExpUnicodeEscapeSequence(forceUFlag)
         ) {
             cp = this._lastIntValue
@@ -1945,7 +2965,7 @@ export class RegExpValidator {
             this.advance()
         }
 
-        if (isRegExpIdentifierPart(cp)) {
+        if (isIdentifierPartChar(cp)) {
             this._lastIntValue = cp
             return true
         }
@@ -1957,7 +2977,7 @@ export class RegExpValidator {
     }
 
     /**
-     * Eat the next characters as the follwoing alternatives if possible.
+     * Eat the next characters as the following alternatives if possible.
      * Set `this._lastIntValue` if it ate the next characters successfully.
      * ```
      *      `c` ControlLetter
@@ -1966,7 +2986,7 @@ export class RegExpValidator {
      */
     private eatCControlLetter(): boolean {
         const start = this.index
-        if (this.eat(LatinSmallLetterC)) {
+        if (this.eat(LATIN_SMALL_LETTER_C)) {
             if (this.eatControlLetter()) {
                 return true
             }
@@ -1976,7 +2996,7 @@ export class RegExpValidator {
     }
 
     /**
-     * Eat the next characters as the follwoing alternatives if possible.
+     * Eat the next characters as the following alternatives if possible.
      * Set `this._lastIntValue` if it ate the next characters successfully.
      * ```
      *      `0` [lookahead ∉ DecimalDigit]
@@ -1985,7 +3005,7 @@ export class RegExpValidator {
      */
     private eatZero(): boolean {
         if (
-            this.currentCodePoint === DigitZero &&
+            this.currentCodePoint === DIGIT_ZERO &&
             !isDecimalDigit(this.nextCodePoint)
         ) {
             this._lastIntValue = 0
@@ -2006,24 +3026,24 @@ export class RegExpValidator {
      * @returns `true` if it ate the next characters successfully.
      */
     private eatControlEscape(): boolean {
-        if (this.eat(LatinSmallLetterF)) {
-            this._lastIntValue = FormFeed
+        if (this.eat(LATIN_SMALL_LETTER_F)) {
+            this._lastIntValue = FORM_FEED
             return true
         }
-        if (this.eat(LatinSmallLetterN)) {
-            this._lastIntValue = LineFeed
+        if (this.eat(LATIN_SMALL_LETTER_N)) {
+            this._lastIntValue = LINE_FEED
             return true
         }
-        if (this.eat(LatinSmallLetterR)) {
-            this._lastIntValue = CarriageReturn
+        if (this.eat(LATIN_SMALL_LETTER_R)) {
+            this._lastIntValue = CARRIAGE_RETURN
             return true
         }
-        if (this.eat(LatinSmallLetterT)) {
-            this._lastIntValue = CharacterTabulation
+        if (this.eat(LATIN_SMALL_LETTER_T)) {
+            this._lastIntValue = CHARACTER_TABULATION
             return true
         }
-        if (this.eat(LatinSmallLetterV)) {
-            this._lastIntValue = LineTabulation
+        if (this.eat(LATIN_SMALL_LETTER_V)) {
+            this._lastIntValue = LINE_TABULATION
             return true
         }
         return false
@@ -2055,21 +3075,21 @@ export class RegExpValidator {
      * production if possible.
      * Set `this._lastIntValue` if it ate the next characters successfully.
      * ```
-     * RegExpUnicodeEscapeSequence[U]::
-     *      [+U] `u` LeadSurrogate `\u` TrailSurrogate
-     *      [+U] `u` LeadSurrogate
-     *      [+U] `u` TrailSurrogate
-     *      [+U] `u` NonSurrogate
-     *      [~U] `u` Hex4Digits
-     *      [+U] `u{` CodePoint `}`
+     * RegExpUnicodeEscapeSequence[UnicodeMode]::
+     *      [+UnicodeMode] `u` HexLeadSurrogate `\u` HexTrailSurrogate
+     *      [+UnicodeMode] `u` HexLeadSurrogate
+     *      [+UnicodeMode] `u` HexTrailSurrogate
+     *      [+UnicodeMode] `u` HexNonSurrogate
+     *      [~UnicodeMode] `u` Hex4Digits
+     *      [+UnicodeMode] `u{` CodePoint `}`
      * ```
      * @returns `true` if it ate the next characters successfully.
      */
     private eatRegExpUnicodeEscapeSequence(forceUFlag = false): boolean {
         const start = this.index
-        const uFlag = forceUFlag || this._uFlag
+        const uFlag = forceUFlag || this._unicodeMode
 
-        if (this.eat(LatinSmallLetterU)) {
+        if (this.eat(LATIN_SMALL_LETTER_U)) {
             if (
                 (uFlag && this.eatRegExpUnicodeSurrogatePairEscape()) ||
                 this.eatFixedHexDigits(4) ||
@@ -2090,7 +3110,7 @@ export class RegExpValidator {
      * Eat the next characters as the following alternatives if possible.
      * Set `this._lastIntValue` if it ate the next characters successfully.
      * ```
-     *      LeadSurrogate `\u` TrailSurrogate
+     *      HexLeadSurrogate `\u` HexTrailSurrogate
      * ```
      * @returns `true` if it ate the next characters successfully.
      */
@@ -2101,8 +3121,8 @@ export class RegExpValidator {
             const lead = this._lastIntValue
             if (
                 isLeadSurrogate(lead) &&
-                this.eat(ReverseSolidus) &&
-                this.eat(LatinSmallLetterU) &&
+                this.eat(REVERSE_SOLIDUS) &&
+                this.eat(LATIN_SMALL_LETTER_U) &&
                 this.eatFixedHexDigits(4)
             ) {
                 const trail = this._lastIntValue
@@ -2130,9 +3150,9 @@ export class RegExpValidator {
         const start = this.index
 
         if (
-            this.eat(LeftCurlyBracket) &&
+            this.eat(LEFT_CURLY_BRACKET) &&
             this.eatHexDigits() &&
-            this.eat(RightCurlyBracket) &&
+            this.eat(RIGHT_CURLY_BRACKET) &&
             isValidUnicode(this._lastIntValue)
         ) {
             return true
@@ -2147,11 +3167,11 @@ export class RegExpValidator {
      * possible.
      * Set `this._lastIntValue` if it ate the next characters successfully.
      * ```
-     * IdentityEscape[U, N]::
-     *      [+U] SyntaxCharacter
-     *      [+U] `/`
-     *      [strict][~U] SourceCharacter but not UnicodeIDContinue
-     *      [annexB][~U] SourceCharacterIdentityEscape[?N]
+     * IdentityEscape[UnicodeMode, N]::
+     *      [+UnicodeMode] SyntaxCharacter
+     *      [+UnicodeMode] `/`
+     *      [strict][~UnicodeMode] SourceCharacter but not UnicodeIDContinue
+     *      [annexB][~UnicodeMode] SourceCharacterIdentityEscape[?N]
      * SourceCharacterIdentityEscape[N]::
      *      [~N] SourceCharacter but not c
      *      [+N] SourceCharacter but not one of c k
@@ -2167,20 +3187,21 @@ export class RegExpValidator {
         }
         return false
     }
+
     private isValidIdentityEscape(cp: number): boolean {
         if (cp === -1) {
             return false
         }
-        if (this._uFlag) {
-            return isSyntaxCharacter(cp) || cp === Solidus
+        if (this._unicodeMode) {
+            return isSyntaxCharacter(cp) || cp === SOLIDUS
         }
         if (this.strict) {
             return !isIdContinue(cp)
         }
         if (this._nFlag) {
-            return !(cp === LatinSmallLetterC || cp === LatinSmallLetterK)
+            return !(cp === LATIN_SMALL_LETTER_C || cp === LATIN_SMALL_LETTER_K)
         }
-        return cp !== LatinSmallLetterC
+        return cp !== LATIN_SMALL_LETTER_C
     }
 
     /**
@@ -2196,13 +3217,13 @@ export class RegExpValidator {
     private eatDecimalEscape(): boolean {
         this._lastIntValue = 0
         let cp = this.currentCodePoint
-        if (cp >= DigitOne && cp <= DigitNine) {
+        if (cp >= DIGIT_ONE && cp <= DIGIT_NINE) {
             do {
-                this._lastIntValue = 10 * this._lastIntValue + (cp - DigitZero)
+                this._lastIntValue = 10 * this._lastIntValue + (cp - DIGIT_ZERO)
                 this.advance()
             } while (
-                (cp = this.currentCodePoint) >= DigitZero &&
-                cp <= DigitNine
+                (cp = this.currentCodePoint) >= DIGIT_ZERO &&
+                cp <= DIGIT_NINE
             )
             return true
         }
@@ -2212,31 +3233,28 @@ export class RegExpValidator {
     /**
      * Eat the next characters as a RegExp `UnicodePropertyValueExpression`
      * production if possible.
-     * Set `this._lastKeyValue` and `this._lastValValue` if it ate the next
+     * Set `this._lastProperty` if it ate the next
      * characters successfully.
      * ```
      * UnicodePropertyValueExpression::
      *      UnicodePropertyName `=` UnicodePropertyValue
      *      LoneUnicodePropertyNameOrValue
      * ```
-     * @returns `true` if it ate the next characters successfully.
+     * @returns the object if it ate the next characters successfully.
      */
-    private eatUnicodePropertyValueExpression(): boolean {
+    private eatUnicodePropertyValueExpression(): UnicodePropertyValueExpressionConsumeResult | null {
         const start = this.index
 
         // UnicodePropertyName `=` UnicodePropertyValue
-        if (this.eatUnicodePropertyName() && this.eat(EqualsSign)) {
-            this._lastKeyValue = this._lastStrValue
+        if (this.eatUnicodePropertyName() && this.eat(EQUALS_SIGN)) {
+            const key = this._lastStrValue
             if (this.eatUnicodePropertyValue()) {
-                this._lastValValue = this._lastStrValue
-                if (
-                    isValidUnicodeProperty(
-                        this.ecmaVersion,
-                        this._lastKeyValue,
-                        this._lastValValue,
-                    )
-                ) {
-                    return true
+                const value = this._lastStrValue
+                if (isValidUnicodeProperty(this.ecmaVersion, key, value)) {
+                    return {
+                        key,
+                        value: value || null,
+                    }
                 }
                 this.raise("Invalid property name")
             }
@@ -2253,18 +3271,33 @@ export class RegExpValidator {
                     nameOrValue,
                 )
             ) {
-                this._lastKeyValue = "General_Category"
-                this._lastValValue = nameOrValue
-                return true
+                return {
+                    key: "General_Category",
+                    value: nameOrValue || null,
+                }
             }
             if (isValidLoneUnicodeProperty(this.ecmaVersion, nameOrValue)) {
-                this._lastKeyValue = nameOrValue
-                this._lastValValue = ""
-                return true
+                return {
+                    key: nameOrValue,
+                    value: null,
+                }
+            }
+            if (
+                this._unicodeSetsMode &&
+                isValidLoneUnicodePropertyOfString(
+                    this.ecmaVersion,
+                    nameOrValue,
+                )
+            ) {
+                return {
+                    key: nameOrValue,
+                    value: null,
+                    strings: true,
+                }
             }
             this.raise("Invalid property name")
         }
-        return false
+        return null
     }
 
     /**
@@ -2332,11 +3365,11 @@ export class RegExpValidator {
      */
     private eatHexEscapeSequence(): boolean {
         const start = this.index
-        if (this.eat(LatinSmallLetterX)) {
+        if (this.eat(LATIN_SMALL_LETTER_X)) {
             if (this.eatFixedHexDigits(2)) {
                 return true
             }
-            if (this._uFlag || this.strict) {
+            if (this._unicodeMode || this.strict) {
                 this.raise("Invalid escape")
             }
             this.rewind(start)
@@ -2441,7 +3474,7 @@ export class RegExpValidator {
         const cp = this.currentCodePoint
         if (isOctalDigit(cp)) {
             this.advance()
-            this._lastIntValue = cp - DigitZero
+            this._lastIntValue = cp - DIGIT_ZERO
             return true
         }
         this._lastIntValue = 0
@@ -2472,4 +3505,93 @@ export class RegExpValidator {
         }
         return true
     }
+
+    /**
+     * Eat the next characters as the following alternatives.
+     * ```
+     * RegularExpressionFlags ::
+     *      [empty]
+     *      RegularExpressionFlags RegularExpressionModifier
+     * ```
+     * @returns `true` if it ate the next characters successfully.
+     */
+    private eatModifiers(): boolean {
+        let ate = false
+        while (isRegularExpressionModifier(this.currentCodePoint)) {
+            this.advance()
+            ate = true
+        }
+        return ate
+    }
+
+    /**
+     * Parse a regexp modifiers. E.g. "ims"
+     * @param start The start index in the source code.
+     * @param end The end index in the source code.
+     */
+    private parseModifiers(start: number, end: number) {
+        const { ignoreCase, multiline, dotAll } = this.parseFlags(
+            this._reader.source,
+            start,
+            end,
+        )
+
+        return { ignoreCase, multiline, dotAll }
+    }
+
+    /**
+     * Parse a regexp flags. E.g. "ims"
+     * @param start The start index in the source code.
+     * @param end The end index in the source code.
+     */
+    private parseFlags(
+        source: string,
+        start: number,
+        end: number,
+    ): FlagsRecord {
+        const flags = {
+            global: false,
+            ignoreCase: false,
+            multiline: false,
+            unicode: false,
+            sticky: false,
+            dotAll: false,
+            hasIndices: false,
+            unicodeSets: false,
+        }
+
+        const validFlags = new Set<FlagCodePoint>()
+        validFlags.add(LATIN_SMALL_LETTER_G)
+        validFlags.add(LATIN_SMALL_LETTER_I)
+        validFlags.add(LATIN_SMALL_LETTER_M)
+        if (this.ecmaVersion >= 2015) {
+            validFlags.add(LATIN_SMALL_LETTER_U)
+            validFlags.add(LATIN_SMALL_LETTER_Y)
+            if (this.ecmaVersion >= 2018) {
+                validFlags.add(LATIN_SMALL_LETTER_S)
+                if (this.ecmaVersion >= 2022) {
+                    validFlags.add(LATIN_SMALL_LETTER_D)
+                    if (this.ecmaVersion >= 2024) {
+                        validFlags.add(LATIN_SMALL_LETTER_V)
+                    }
+                }
+            }
+        }
+
+        for (let i = start; i < end; ++i) {
+            const flag = source.charCodeAt(i) as FlagCodePoint
+            if (validFlags.has(flag)) {
+                const prop = FLAG_CODEPOINT_TO_PROP[flag]
+                if (flags[prop]) {
+                    this.raise(`Duplicated flag '${source[i]}'`, {
+                        index: start,
+                    })
+                }
+                flags[prop] = true
+            } else {
+                this.raise(`Invalid flag '${source[i]}'`, { index: start })
+            }
+        }
+        return flags
+    }
 }
diff --git a/src/visitor.ts b/src/visitor.ts
index 9a72ba9..a2cb2a0 100644
--- a/src/visitor.ts
+++ b/src/visitor.ts
@@ -1,4 +1,4 @@
-import {
+import type {
     Alternative,
     Assertion,
     Backreference,
@@ -7,12 +7,19 @@ import {
     CharacterClass,
     CharacterClassRange,
     CharacterSet,
+    ClassIntersection,
+    ClassStringDisjunction,
+    ClassSubtraction,
+    ExpressionCharacterClass,
     Flags,
     Group,
+    ModifierFlags,
+    Modifiers,
     Node,
     Pattern,
     Quantifier,
     RegExpLiteral,
+    StringAlternative,
 } from "./ast"
 
 /**
@@ -33,6 +40,7 @@ export class RegExpVisitor {
      * Visit a given node and descendant nodes.
      * @param node The root node to visit tree.
      */
+    // eslint-disable-next-line complexity
     public visit(node: Node): void {
         switch (node.type) {
             case "Alternative":
@@ -59,12 +67,30 @@ export class RegExpVisitor {
             case "CharacterSet":
                 this.visitCharacterSet(node)
                 break
+            case "ClassIntersection":
+                this.visitClassIntersection(node)
+                break
+            case "ClassStringDisjunction":
+                this.visitClassStringDisjunction(node)
+                break
+            case "ClassSubtraction":
+                this.visitClassSubtraction(node)
+                break
+            case "ExpressionCharacterClass":
+                this.visitExpressionCharacterClass(node)
+                break
             case "Flags":
                 this.visitFlags(node)
                 break
             case "Group":
                 this.visitGroup(node)
                 break
+            case "Modifiers":
+                this.visitModifiers(node)
+                break
+            case "ModifierFlags":
+                this.visitModifierFlags(node)
+                break
             case "Pattern":
                 this.visitPattern(node)
                 break
@@ -74,8 +100,13 @@ export class RegExpVisitor {
             case "RegExpLiteral":
                 this.visitRegExpLiteral(node)
                 break
+            case "StringAlternative":
+                this.visitStringAlternative(node)
+                break
             default:
-                throw new Error(`Unknown type: ${(node as any).type}`)
+                throw new Error(
+                    `Unknown type: ${(node as Pick<Node, "type">).type}`,
+                )
         }
     }
 
@@ -88,6 +119,7 @@ export class RegExpVisitor {
             this._handlers.onAlternativeLeave(node)
         }
     }
+
     private visitAssertion(node: Assertion): void {
         if (this._handlers.onAssertionEnter) {
             this._handlers.onAssertionEnter(node)
@@ -99,6 +131,7 @@ export class RegExpVisitor {
             this._handlers.onAssertionLeave(node)
         }
     }
+
     private visitBackreference(node: Backreference): void {
         if (this._handlers.onBackreferenceEnter) {
             this._handlers.onBackreferenceEnter(node)
@@ -107,6 +140,7 @@ export class RegExpVisitor {
             this._handlers.onBackreferenceLeave(node)
         }
     }
+
     private visitCapturingGroup(node: CapturingGroup): void {
         if (this._handlers.onCapturingGroupEnter) {
             this._handlers.onCapturingGroupEnter(node)
@@ -116,6 +150,7 @@ export class RegExpVisitor {
             this._handlers.onCapturingGroupLeave(node)
         }
     }
+
     private visitCharacter(node: Character): void {
         if (this._handlers.onCharacterEnter) {
             this._handlers.onCharacterEnter(node)
@@ -124,6 +159,7 @@ export class RegExpVisitor {
             this._handlers.onCharacterLeave(node)
         }
     }
+
     private visitCharacterClass(node: CharacterClass): void {
         if (this._handlers.onCharacterClassEnter) {
             this._handlers.onCharacterClassEnter(node)
@@ -133,6 +169,7 @@ export class RegExpVisitor {
             this._handlers.onCharacterClassLeave(node)
         }
     }
+
     private visitCharacterClassRange(node: CharacterClassRange): void {
         if (this._handlers.onCharacterClassRangeEnter) {
             this._handlers.onCharacterClassRangeEnter(node)
@@ -143,6 +180,7 @@ export class RegExpVisitor {
             this._handlers.onCharacterClassRangeLeave(node)
         }
     }
+
     private visitCharacterSet(node: CharacterSet): void {
         if (this._handlers.onCharacterSetEnter) {
             this._handlers.onCharacterSetEnter(node)
@@ -151,6 +189,51 @@ export class RegExpVisitor {
             this._handlers.onCharacterSetLeave(node)
         }
     }
+
+    private visitClassIntersection(node: ClassIntersection): void {
+        if (this._handlers.onClassIntersectionEnter) {
+            this._handlers.onClassIntersectionEnter(node)
+        }
+        this.visit(node.left)
+        this.visit(node.right)
+        if (this._handlers.onClassIntersectionLeave) {
+            this._handlers.onClassIntersectionLeave(node)
+        }
+    }
+
+    private visitClassStringDisjunction(node: ClassStringDisjunction): void {
+        if (this._handlers.onClassStringDisjunctionEnter) {
+            this._handlers.onClassStringDisjunctionEnter(node)
+        }
+        node.alternatives.forEach(this.visit, this)
+        if (this._handlers.onClassStringDisjunctionLeave) {
+            this._handlers.onClassStringDisjunctionLeave(node)
+        }
+    }
+
+    private visitClassSubtraction(node: ClassSubtraction): void {
+        if (this._handlers.onClassSubtractionEnter) {
+            this._handlers.onClassSubtractionEnter(node)
+        }
+        this.visit(node.left)
+        this.visit(node.right)
+        if (this._handlers.onClassSubtractionLeave) {
+            this._handlers.onClassSubtractionLeave(node)
+        }
+    }
+
+    private visitExpressionCharacterClass(
+        node: ExpressionCharacterClass,
+    ): void {
+        if (this._handlers.onExpressionCharacterClassEnter) {
+            this._handlers.onExpressionCharacterClassEnter(node)
+        }
+        this.visit(node.expression)
+        if (this._handlers.onExpressionCharacterClassLeave) {
+            this._handlers.onExpressionCharacterClassLeave(node)
+        }
+    }
+
     private visitFlags(node: Flags): void {
         if (this._handlers.onFlagsEnter) {
             this._handlers.onFlagsEnter(node)
@@ -159,15 +242,44 @@ export class RegExpVisitor {
             this._handlers.onFlagsLeave(node)
         }
     }
+
     private visitGroup(node: Group): void {
         if (this._handlers.onGroupEnter) {
             this._handlers.onGroupEnter(node)
         }
+        if (node.modifiers) {
+            this.visit(node.modifiers)
+        }
         node.alternatives.forEach(this.visit, this)
         if (this._handlers.onGroupLeave) {
             this._handlers.onGroupLeave(node)
         }
     }
+
+    private visitModifiers(node: Modifiers): void {
+        if (this._handlers.onModifiersEnter) {
+            this._handlers.onModifiersEnter(node)
+        }
+        if (node.add) {
+            this.visit(node.add)
+        }
+        if (node.remove) {
+            this.visit(node.remove)
+        }
+        if (this._handlers.onModifiersLeave) {
+            this._handlers.onModifiersLeave(node)
+        }
+    }
+
+    private visitModifierFlags(node: ModifierFlags): void {
+        if (this._handlers.onModifierFlagsEnter) {
+            this._handlers.onModifierFlagsEnter(node)
+        }
+        if (this._handlers.onModifierFlagsLeave) {
+            this._handlers.onModifierFlagsLeave(node)
+        }
+    }
+
     private visitPattern(node: Pattern): void {
         if (this._handlers.onPatternEnter) {
             this._handlers.onPatternEnter(node)
@@ -177,6 +289,7 @@ export class RegExpVisitor {
             this._handlers.onPatternLeave(node)
         }
     }
+
     private visitQuantifier(node: Quantifier): void {
         if (this._handlers.onQuantifierEnter) {
             this._handlers.onQuantifierEnter(node)
@@ -186,6 +299,7 @@ export class RegExpVisitor {
             this._handlers.onQuantifierLeave(node)
         }
     }
+
     private visitRegExpLiteral(node: RegExpLiteral): void {
         if (this._handlers.onRegExpLiteralEnter) {
             this._handlers.onRegExpLiteralEnter(node)
@@ -196,35 +310,63 @@ export class RegExpVisitor {
             this._handlers.onRegExpLiteralLeave(node)
         }
     }
+
+    private visitStringAlternative(node: StringAlternative): void {
+        if (this._handlers.onStringAlternativeEnter) {
+            this._handlers.onStringAlternativeEnter(node)
+        }
+        node.elements.forEach(this.visit, this)
+        if (this._handlers.onStringAlternativeLeave) {
+            this._handlers.onStringAlternativeLeave(node)
+        }
+    }
 }
 
 export namespace RegExpVisitor {
     export interface Handlers {
-        onAlternativeEnter?(node: Alternative): void
-        onAlternativeLeave?(node: Alternative): void
-        onAssertionEnter?(node: Assertion): void
-        onAssertionLeave?(node: Assertion): void
-        onBackreferenceEnter?(node: Backreference): void
-        onBackreferenceLeave?(node: Backreference): void
-        onCapturingGroupEnter?(node: CapturingGroup): void
-        onCapturingGroupLeave?(node: CapturingGroup): void
-        onCharacterEnter?(node: Character): void
-        onCharacterLeave?(node: Character): void
-        onCharacterClassEnter?(node: CharacterClass): void
-        onCharacterClassLeave?(node: CharacterClass): void
-        onCharacterClassRangeEnter?(node: CharacterClassRange): void
-        onCharacterClassRangeLeave?(node: CharacterClassRange): void
-        onCharacterSetEnter?(node: CharacterSet): void
-        onCharacterSetLeave?(node: CharacterSet): void
-        onFlagsEnter?(node: Flags): void
-        onFlagsLeave?(node: Flags): void
-        onGroupEnter?(node: Group): void
-        onGroupLeave?(node: Group): void
-        onPatternEnter?(node: Pattern): void
-        onPatternLeave?(node: Pattern): void
-        onQuantifierEnter?(node: Quantifier): void
-        onQuantifierLeave?(node: Quantifier): void
-        onRegExpLiteralEnter?(node: RegExpLiteral): void
-        onRegExpLiteralLeave?(node: RegExpLiteral): void
+        onAlternativeEnter?: (node: Alternative) => void
+        onAlternativeLeave?: (node: Alternative) => void
+        onAssertionEnter?: (node: Assertion) => void
+        onAssertionLeave?: (node: Assertion) => void
+        onBackreferenceEnter?: (node: Backreference) => void
+        onBackreferenceLeave?: (node: Backreference) => void
+        onCapturingGroupEnter?: (node: CapturingGroup) => void
+        onCapturingGroupLeave?: (node: CapturingGroup) => void
+        onCharacterEnter?: (node: Character) => void
+        onCharacterLeave?: (node: Character) => void
+        onCharacterClassEnter?: (node: CharacterClass) => void
+        onCharacterClassLeave?: (node: CharacterClass) => void
+        onCharacterClassRangeEnter?: (node: CharacterClassRange) => void
+        onCharacterClassRangeLeave?: (node: CharacterClassRange) => void
+        onCharacterSetEnter?: (node: CharacterSet) => void
+        onCharacterSetLeave?: (node: CharacterSet) => void
+        onClassIntersectionEnter?: (node: ClassIntersection) => void
+        onClassIntersectionLeave?: (node: ClassIntersection) => void
+        onClassStringDisjunctionEnter?: (node: ClassStringDisjunction) => void
+        onClassStringDisjunctionLeave?: (node: ClassStringDisjunction) => void
+        onClassSubtractionEnter?: (node: ClassSubtraction) => void
+        onClassSubtractionLeave?: (node: ClassSubtraction) => void
+        onExpressionCharacterClassEnter?: (
+            node: ExpressionCharacterClass,
+        ) => void
+        onExpressionCharacterClassLeave?: (
+            node: ExpressionCharacterClass,
+        ) => void
+        onFlagsEnter?: (node: Flags) => void
+        onFlagsLeave?: (node: Flags) => void
+        onGroupEnter?: (node: Group) => void
+        onGroupLeave?: (node: Group) => void
+        onModifierFlagsEnter?: (node: ModifierFlags) => void
+        onModifierFlagsLeave?: (node: ModifierFlags) => void
+        onModifiersEnter?: (node: Modifiers) => void
+        onModifiersLeave?: (node: Modifiers) => void
+        onPatternEnter?: (node: Pattern) => void
+        onPatternLeave?: (node: Pattern) => void
+        onQuantifierEnter?: (node: Quantifier) => void
+        onQuantifierLeave?: (node: Quantifier) => void
+        onRegExpLiteralEnter?: (node: RegExpLiteral) => void
+        onRegExpLiteralLeave?: (node: RegExpLiteral) => void
+        onStringAlternativeEnter?: (node: StringAlternative) => void
+        onStringAlternativeLeave?: (node: StringAlternative) => void
     }
 }
diff --git a/test/fixtures/parser/literal.ts b/test/fixtures/parser/literal.ts
index df61562..8703e9d 100644
--- a/test/fixtures/parser/literal.ts
+++ b/test/fixtures/parser/literal.ts
@@ -1,49 +1,53 @@
 import fs from "fs"
 import path from "path"
+import type { EcmaVersion } from "../../../src/ecma-versions"
 
-type FixtureData = {
-    [filename: string]: {
+type FixtureData = Record<
+    string,
+    {
         options: {
             strict: boolean
-            ecmaVersion:
-                | 5
-                | 2015
-                | 2016
-                | 2017
-                | 2018
-                | 2019
-                | 2020
-                | 2021
-                | 2022
-        }
-        patterns: {
-            [source: string]:
-                | { ast: object }
-                | { error: { message: string; index: number } }
+            ecmaVersion: EcmaVersion
         }
+        patterns: Record<
+            string,
+            { ast: object } | { error: { message: string; index: number } }
+        >
     }
-}
+>
 
-const Fixtures: FixtureData = {}
+export const fixturesData: FixtureData = {}
 const fixturesRoot = path.join(__dirname, "literal")
-for (const filename of fs.readdirSync(fixturesRoot)) {
-    Fixtures[filename] = JSON.parse(
+for (const filename of extractFixtureFiles(fixturesRoot)) {
+    fixturesData[filename] = JSON.parse(
         fs.readFileSync(path.join(fixturesRoot, filename), "utf8"),
-        (_, v) => (v === "$$Infinity" ? Infinity : v),
-    )
+        (_, v: unknown) => (v === "$$Infinity" ? Infinity : v),
+    ) as FixtureData[string]
 }
 
 export function save(): void {
-    for (const filename of Object.keys(Fixtures)) {
+    for (const filename of Object.keys(fixturesData)) {
         fs.writeFileSync(
             path.join(fixturesRoot, filename),
             JSON.stringify(
-                Fixtures[filename],
-                (_, v) => (v === Infinity ? "$$Infinity" : v),
+                fixturesData[filename],
+                (_, v: unknown) => (v === Infinity ? "$$Infinity" : v),
                 2,
             ),
         )
     }
 }
 
-export { Fixtures }
+function* extractFixtureFiles(dir: string): Iterable<string> {
+    for (const dirent of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (dirent.isDirectory()) {
+            for (const name of extractFixtureFiles(
+                path.join(dir, dirent.name),
+            )) {
+                yield path.join(dirent.name, name)
+            }
+        } else if (dirent.name.endsWith(".json")) {
+            yield dirent.name
+        }
+    }
+}
diff --git a/test/fixtures/parser/literal/basic-valid-2015-u.json b/test/fixtures/parser/literal/basic-valid-2015-u.json
index af92810..7e510e2 100644
--- a/test/fixtures/parser/literal/basic-valid-2015-u.json
+++ b/test/fixtures/parser/literal/basic-valid-2015-u.json
@@ -65,7 +65,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -163,7 +164,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -235,7 +237,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -337,7 +340,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -397,7 +401,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -482,7 +487,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -542,7 +548,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -627,7 +634,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -686,7 +694,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -745,7 +754,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -804,7 +814,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -863,7 +874,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -922,7 +934,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -981,7 +994,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1040,7 +1054,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1099,7 +1114,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1158,7 +1174,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1217,7 +1234,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1276,7 +1294,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1335,7 +1354,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1408,7 +1428,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1457,7 +1478,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1506,7 +1528,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1555,7 +1578,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1603,7 +1627,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1665,6 +1690,7 @@
                   "end": 6,
                   "raw": "\\1",
                   "ref": 1,
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -1683,7 +1709,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1715,6 +1742,7 @@
                   "end": 3,
                   "raw": "\\1",
                   "ref": 1,
+                  "ambiguous": false,
                   "resolved": "♻️../1"
                 },
                 {
@@ -1763,7 +1791,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2077,6 +2106,7 @@
                   "end": 34,
                   "raw": "\\10",
                   "ref": 10,
+                  "ambiguous": false,
                   "resolved": "♻️../9"
                 }
               ]
@@ -2095,7 +2125,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2437,6 +2468,7 @@
                   "end": 37,
                   "raw": "\\11",
                   "ref": 11,
+                  "ambiguous": false,
                   "resolved": "♻️../10"
                 }
               ]
@@ -2455,7 +2487,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2486,6 +2519,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "(?:a)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -2522,7 +2556,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2572,7 +2607,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2622,7 +2658,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2672,7 +2709,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2722,7 +2760,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2772,7 +2811,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2822,7 +2862,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2871,7 +2912,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2920,7 +2962,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2969,7 +3012,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3018,7 +3062,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3067,7 +3112,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3116,7 +3162,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3165,7 +3212,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3214,7 +3262,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3263,7 +3312,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3320,7 +3370,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3369,7 +3420,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3418,7 +3470,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3467,7 +3520,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3516,7 +3570,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3565,7 +3620,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3614,7 +3670,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3663,7 +3720,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3712,7 +3770,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3761,7 +3820,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3810,7 +3870,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3859,7 +3920,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3908,7 +3970,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3957,7 +4020,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4006,7 +4070,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4055,7 +4120,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4104,7 +4170,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4153,7 +4220,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4184,6 +4252,7 @@
                   "start": 1,
                   "end": 3,
                   "raw": "[]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": []
                 }
@@ -4203,7 +4272,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4234,6 +4304,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[^-a-b-]",
+                  "unicodeSets": false,
                   "negate": true,
                   "elements": [
                     {
@@ -4293,7 +4364,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4324,6 +4396,7 @@
                   "start": 1,
                   "end": 4,
                   "raw": "[-]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -4352,7 +4425,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4383,6 +4457,7 @@
                   "start": 1,
                   "end": 4,
                   "raw": "[a]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -4411,7 +4486,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4442,6 +4518,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[--]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -4478,7 +4555,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4509,6 +4587,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[-a]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -4545,7 +4624,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4576,6 +4656,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[-a-]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -4620,7 +4701,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4651,6 +4733,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[a-]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -4687,7 +4770,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4718,6 +4802,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[a-b]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -4761,7 +4846,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4792,6 +4878,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[-a-b-]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -4851,7 +4938,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4882,6 +4970,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[---]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -4925,7 +5014,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4956,6 +5046,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[a-b--/]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5022,7 +5113,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5053,6 +5145,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\b-\\n]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5096,7 +5189,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5127,6 +5221,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[b\\-a]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5171,7 +5266,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5202,6 +5298,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\d]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5231,7 +5328,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5262,6 +5360,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\D]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5291,7 +5390,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5322,6 +5422,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\s]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5351,7 +5452,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5382,6 +5484,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\S]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5411,7 +5514,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5442,6 +5546,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\w]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5471,7 +5576,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5502,6 +5608,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\W]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5531,7 +5638,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5562,6 +5670,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\f]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5590,7 +5699,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5621,6 +5731,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\n]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5649,7 +5760,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5680,6 +5792,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\r]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5708,7 +5821,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5739,6 +5853,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\t]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5767,7 +5882,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5798,6 +5914,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\v]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5826,7 +5943,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5857,6 +5975,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\cA]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5885,7 +6004,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5916,6 +6036,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\cz]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -5944,7 +6065,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5975,6 +6097,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\0]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6003,7 +6126,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6034,6 +6158,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[\\x12]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6062,7 +6187,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6093,6 +6219,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\x123]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6129,7 +6256,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6160,6 +6288,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[\\u1234]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6188,7 +6317,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6219,6 +6349,7 @@
                   "start": 1,
                   "end": 10,
                   "raw": "[\\u12345]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6255,7 +6386,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6286,6 +6418,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\u{a}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6314,7 +6447,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6345,6 +6479,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[\\u{20}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6373,7 +6508,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6404,6 +6540,7 @@
                   "start": 1,
                   "end": 13,
                   "raw": "[\\u{10FFFF}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6432,7 +6569,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6463,6 +6601,7 @@
                   "start": 1,
                   "end": 15,
                   "raw": "[\\u{00000001}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6491,7 +6630,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6522,6 +6662,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\^]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6550,7 +6691,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6581,6 +6723,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\$]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6609,7 +6752,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6640,6 +6784,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\.]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6668,7 +6813,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6699,6 +6845,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\+]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6727,7 +6874,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6758,6 +6906,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\?]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6786,7 +6935,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6817,6 +6967,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\(]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6845,7 +6996,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6876,6 +7028,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\)]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6904,7 +7057,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6935,6 +7089,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\[]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -6963,7 +7118,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6994,6 +7150,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\]]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7022,7 +7179,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7053,6 +7211,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\{]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7081,7 +7240,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7112,6 +7272,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7140,7 +7301,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7171,6 +7333,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\|]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7199,7 +7362,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7230,6 +7394,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\/]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7258,7 +7423,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7289,6 +7455,7 @@
                   "start": 1,
                   "end": 16,
                   "raw": "[\\u0000-\\u0001]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7332,7 +7499,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7363,6 +7531,7 @@
                   "start": 1,
                   "end": 14,
                   "raw": "[\\u{1}-\\u{2}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7406,7 +7575,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7437,6 +7607,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[0-9--/]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7503,7 +7674,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7534,6 +7706,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[🌷-🌸]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7577,7 +7750,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7608,6 +7782,7 @@
                   "start": 1,
                   "end": 19,
                   "raw": "[\\u0000-🌸-\\u0000]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7667,7 +7842,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7698,6 +7874,7 @@
                   "start": 1,
                   "end": 26,
                   "raw": "[\\u0000-\\u{1f338}-\\u0000]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7757,7 +7934,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7788,6 +7966,7 @@
                   "start": 1,
                   "end": 29,
                   "raw": "[\\u0000-\\ud83c\\udf38-\\u0000]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7847,7 +8026,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7878,6 +8058,7 @@
                   "start": 1,
                   "end": 31,
                   "raw": "[\\uD834\\uDF06-\\uD834\\uDF08a-z]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7944,7 +8125,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7992,6 +8174,7 @@
                     "start": 2,
                     "end": 7,
                     "raw": "[0-9]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -8044,7 +8227,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8092,6 +8276,7 @@
                     "start": 2,
                     "end": 7,
                     "raw": "[0-9]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -8144,7 +8329,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8192,6 +8378,7 @@
                     "start": 2,
                     "end": 10,
                     "raw": "[a-zA-Z]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -8267,7 +8454,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8315,6 +8503,7 @@
                     "start": 2,
                     "end": 10,
                     "raw": "[a-zA-Z]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -8390,7 +8579,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8438,6 +8628,7 @@
                     "start": 2,
                     "end": 13,
                     "raw": "[0-9a-zA-Z]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -8536,7 +8727,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8584,6 +8776,7 @@
                     "start": 2,
                     "end": 26,
                     "raw": "[a-zA-Z0-9!-/:-@\\[-`{-~]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -8774,7 +8967,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8837,6 +9031,7 @@
                             "start": 3,
                             "end": 14,
                             "raw": "[a-zA-Z0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -8940,7 +9135,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9003,6 +9199,7 @@
                             "start": 3,
                             "end": 14,
                             "raw": "[a-zA-Z0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -9106,7 +9303,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9169,6 +9367,7 @@
                             "start": 3,
                             "end": 8,
                             "raw": "[0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -9226,7 +9425,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9274,6 +9474,7 @@
                     "start": 2,
                     "end": 7,
                     "raw": "[0-9]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -9326,7 +9527,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9449,7 +9651,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9552,7 +9755,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9685,7 +9889,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9739,6 +9944,7 @@
                           "start": 3,
                           "end": 8,
                           "raw": "[1-9]",
+                          "unicodeSets": false,
                           "negate": false,
                           "elements": [
                             {
@@ -9781,6 +9987,7 @@
                             "start": 8,
                             "end": 13,
                             "raw": "[0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -9878,6 +10085,7 @@
                               "start": 20,
                               "end": 25,
                               "raw": "[0-9]",
+                              "unicodeSets": false,
                               "negate": false,
                               "elements": [
                                 {
@@ -9936,7 +10144,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10008,6 +10217,7 @@
                           "start": 5,
                           "end": 10,
                           "raw": "[1-9]",
+                          "unicodeSets": false,
                           "negate": false,
                           "elements": [
                             {
@@ -10050,6 +10260,7 @@
                             "start": 10,
                             "end": 15,
                             "raw": "[0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -10147,6 +10358,7 @@
                               "start": 22,
                               "end": 27,
                               "raw": "[0-9]",
+                              "unicodeSets": false,
                               "negate": false,
                               "elements": [
                                 {
@@ -10205,7 +10417,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10253,6 +10466,7 @@
                     "start": 2,
                     "end": 8,
                     "raw": "[ぁ-んー]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -10313,7 +10527,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10361,6 +10576,7 @@
                     "start": 2,
                     "end": 9,
                     "raw": "[ァ-ンヴー]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -10429,7 +10645,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10477,6 +10694,7 @@
                     "start": 2,
                     "end": 11,
                     "raw": "[ｧ-ﾝﾞﾟ\\-]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -10553,7 +10771,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10601,6 +10820,7 @@
                     "start": 2,
                     "end": 14,
                     "raw": "[^\\x20-\\x7e]",
+                    "unicodeSets": false,
                     "negate": true,
                     "elements": [
                       {
@@ -10653,7 +10873,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10701,6 +10922,7 @@
                     "start": 2,
                     "end": 33,
                     "raw": "[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -10958,6 +11180,7 @@
                     "start": 35,
                     "end": 47,
                     "raw": "[a-zA-Z0-9-]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -11055,6 +11278,7 @@
                     "start": 48,
                     "end": 67,
                     "raw": "(?:\\.[a-zA-Z0-9-]+)",
+                    "modifiers": null,
                     "alternatives": [
                       {
                         "type": "Alternative",
@@ -11086,6 +11310,7 @@
                               "start": 53,
                               "end": 65,
                               "raw": "[a-zA-Z0-9-]",
+                              "unicodeSets": false,
                               "negate": false,
                               "elements": [
                                 {
@@ -11197,7 +11422,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11330,6 +11556,7 @@
                                   "start": 14,
                                   "end": 19,
                                   "raw": "[1-5]",
+                                  "unicodeSets": false,
                                   "negate": false,
                                   "elements": [
                                     {
@@ -11477,6 +11704,7 @@
                             "start": 34,
                             "end": 38,
                             "raw": "[- ]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -11552,6 +11780,7 @@
                             "start": 46,
                             "end": 50,
                             "raw": "[- ]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -11627,6 +11856,7 @@
                             "start": 58,
                             "end": 62,
                             "raw": "[- ]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -11695,6 +11925,7 @@
                   "start": 71,
                   "end": 76,
                   "raw": "[4,7]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11766,7 +11997,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11870,7 +12102,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     }
diff --git a/test/fixtures/parser/literal/basic-valid-2015.json b/test/fixtures/parser/literal/basic-valid-2015.json
index 18277a2..36f3603 100644
--- a/test/fixtures/parser/literal/basic-valid-2015.json
+++ b/test/fixtures/parser/literal/basic-valid-2015.json
@@ -65,7 +65,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -163,7 +164,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -235,7 +237,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -337,7 +340,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -397,7 +401,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -482,7 +487,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -542,7 +548,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -627,7 +634,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -706,7 +714,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -785,7 +794,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -864,7 +874,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -941,7 +952,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1026,7 +1038,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1119,7 +1132,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1198,7 +1212,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1277,7 +1292,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1356,7 +1372,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1415,7 +1432,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1474,7 +1492,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1533,7 +1552,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1590,7 +1610,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1655,7 +1676,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1728,7 +1750,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1787,7 +1810,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1852,7 +1876,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1911,7 +1936,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1984,7 +2010,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2043,7 +2070,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2124,7 +2152,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2205,7 +2234,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2264,7 +2294,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2323,7 +2354,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2382,7 +2414,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2449,7 +2482,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2524,7 +2558,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2607,7 +2642,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2666,7 +2702,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2741,7 +2778,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2800,7 +2838,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2883,7 +2922,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2942,7 +2982,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3033,7 +3074,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3124,7 +3166,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3213,7 +3256,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3262,7 +3306,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3311,7 +3356,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3360,7 +3406,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3409,7 +3456,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3458,7 +3506,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3507,7 +3556,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3555,7 +3605,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3636,7 +3687,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3685,7 +3737,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3747,6 +3800,7 @@
                   "end": 6,
                   "raw": "\\1",
                   "ref": 1,
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -3765,7 +3819,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3797,6 +3852,7 @@
                   "end": 3,
                   "raw": "\\1",
                   "ref": 1,
+                  "ambiguous": false,
                   "resolved": "♻️../1"
                 },
                 {
@@ -3845,7 +3901,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3876,6 +3933,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "(?:a)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -3920,7 +3978,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3997,7 +4056,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4028,6 +4088,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "(?:a)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -4072,7 +4133,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4386,6 +4448,7 @@
                   "end": 34,
                   "raw": "\\10",
                   "ref": 10,
+                  "ambiguous": false,
                   "resolved": "♻️../9"
                 }
               ]
@@ -4404,7 +4467,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4733,7 +4797,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5075,6 +5140,7 @@
                   "end": 37,
                   "raw": "\\11",
                   "ref": 11,
+                  "ambiguous": false,
                   "resolved": "♻️../10"
                 }
               ]
@@ -5093,7 +5159,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5124,6 +5191,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "(?:a)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -5160,7 +5228,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5210,7 +5279,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5260,7 +5330,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5310,7 +5381,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5360,7 +5432,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5410,7 +5483,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5460,7 +5534,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5509,7 +5584,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5558,7 +5634,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5607,7 +5684,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5656,7 +5734,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5705,7 +5784,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5754,7 +5834,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5803,7 +5884,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5868,7 +5950,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5925,7 +6008,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5974,7 +6058,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6023,7 +6108,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6080,7 +6166,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6145,7 +6232,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6218,7 +6306,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6267,7 +6356,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6324,7 +6414,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6381,7 +6472,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6446,7 +6538,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6519,7 +6612,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6592,7 +6686,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6651,7 +6746,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6764,7 +6860,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6823,7 +6920,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6882,7 +6980,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6931,7 +7030,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6988,7 +7088,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7037,7 +7138,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7086,7 +7188,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7135,7 +7238,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7184,7 +7288,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7233,7 +7338,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7282,7 +7388,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7331,7 +7438,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7380,7 +7488,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7429,7 +7538,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7478,7 +7588,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7527,7 +7638,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7576,7 +7688,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7625,7 +7738,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7674,7 +7788,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7705,6 +7820,7 @@
                   "start": 1,
                   "end": 3,
                   "raw": "[]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": []
                 }
@@ -7724,7 +7840,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7755,6 +7872,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[^-a-b-]",
+                  "unicodeSets": false,
                   "negate": true,
                   "elements": [
                     {
@@ -7814,7 +7932,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7845,6 +7964,7 @@
                   "start": 1,
                   "end": 4,
                   "raw": "[-]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7873,7 +7993,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7904,6 +8025,7 @@
                   "start": 1,
                   "end": 4,
                   "raw": "[a]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7932,7 +8054,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7963,6 +8086,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[--]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7999,7 +8123,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8030,6 +8155,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[-a]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8066,7 +8192,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8097,6 +8224,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[-a-]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8141,7 +8269,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8172,6 +8301,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[a-]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8208,7 +8338,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8239,6 +8370,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[a-b]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8282,7 +8414,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8313,6 +8446,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[-a-b-]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8372,7 +8506,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8403,6 +8538,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[---]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8446,7 +8582,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8477,6 +8614,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[a-b--/]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8543,7 +8681,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8574,6 +8713,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\b-\\n]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8617,7 +8757,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8648,6 +8789,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[b\\-a]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8692,7 +8834,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8723,6 +8866,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\d]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8752,7 +8896,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8783,6 +8928,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\D]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8812,7 +8958,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8843,6 +8990,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\s]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8872,7 +9020,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8903,6 +9052,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\S]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8932,7 +9082,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8963,6 +9114,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\w]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8992,7 +9144,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9023,6 +9176,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\W]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9052,7 +9206,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9083,6 +9238,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\f]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9111,7 +9267,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9142,6 +9299,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\n]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9170,7 +9328,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9201,6 +9360,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\r]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9229,7 +9389,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9260,6 +9421,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\t]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9288,7 +9450,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9319,6 +9482,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\v]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9347,7 +9511,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9378,6 +9543,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\cA]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9406,7 +9572,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9437,6 +9604,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\cz]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9465,7 +9633,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9496,6 +9665,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\c1]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9524,7 +9694,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9555,6 +9726,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\c]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9591,7 +9763,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9622,6 +9795,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\0]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9650,7 +9824,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9681,6 +9856,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\x]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9709,7 +9885,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9740,6 +9917,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\xz]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9776,7 +9954,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9807,6 +9986,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\x1]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9843,7 +10023,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9874,6 +10055,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[\\x12]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9902,7 +10084,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9933,6 +10116,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\x123]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9969,7 +10153,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10000,6 +10185,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\u]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10028,7 +10214,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10059,6 +10246,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\u1]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10095,7 +10283,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10126,6 +10315,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[\\u12]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10170,7 +10360,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10201,6 +10392,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\u123]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10253,7 +10445,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10284,6 +10477,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[\\u1234]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10312,7 +10506,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10343,6 +10538,7 @@
                   "start": 1,
                   "end": 10,
                   "raw": "[\\u12345]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10379,7 +10575,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10410,6 +10607,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\u{]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10446,7 +10644,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10477,6 +10676,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[\\u{z]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10521,7 +10721,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10552,6 +10753,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\u{a}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10604,7 +10806,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10635,6 +10838,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\u{20]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10687,7 +10891,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10718,6 +10923,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[\\u{20}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10778,7 +10984,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10809,6 +11016,7 @@
                   "start": 1,
                   "end": 13,
                   "raw": "[\\u{10FFFF}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10901,7 +11109,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10932,6 +11141,7 @@
                   "start": 1,
                   "end": 13,
                   "raw": "[\\u{110000}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11024,7 +11234,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11055,6 +11266,7 @@
                   "start": 1,
                   "end": 15,
                   "raw": "[\\u{00000001}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11163,7 +11375,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11194,6 +11407,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\77]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11222,7 +11436,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11253,6 +11468,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[\\377]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11281,7 +11497,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11312,6 +11529,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[\\400]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11348,7 +11566,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11379,6 +11598,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\^]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11407,7 +11627,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11438,6 +11659,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\$]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11466,7 +11688,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11497,6 +11720,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\.]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11525,7 +11749,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11556,6 +11781,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\+]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11584,7 +11810,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11615,6 +11842,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\?]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11643,7 +11871,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11674,6 +11903,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\(]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11702,7 +11932,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11733,6 +11964,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\)]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11761,7 +11993,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11792,6 +12025,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\[]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11820,7 +12054,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11851,6 +12086,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\]]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11879,7 +12115,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11910,6 +12147,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\{]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11938,7 +12176,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11969,6 +12208,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11997,7 +12237,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12028,6 +12269,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\|]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12056,7 +12298,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12087,6 +12330,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\/]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12115,7 +12359,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12146,6 +12391,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\a]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12174,7 +12420,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12205,6 +12452,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\d-\\uFFFF]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12250,7 +12498,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12281,6 +12530,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\D-\\uFFFF]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12326,7 +12576,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12357,6 +12608,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\s-\\uFFFF]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12402,7 +12654,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12433,6 +12686,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\S-\\uFFFF]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12478,7 +12732,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12509,6 +12764,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\w-\\uFFFF]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12554,7 +12810,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12585,6 +12842,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\W-\\uFFFF]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12630,7 +12888,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12661,6 +12920,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\u0000-\\d]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12706,7 +12966,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12737,6 +12998,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\u0000-\\D]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12782,7 +13044,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12813,6 +13076,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\u0000-\\s]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12858,7 +13122,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12889,6 +13154,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\u0000-\\S]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12934,7 +13200,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12965,6 +13232,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\u0000-\\w]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13010,7 +13278,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13041,6 +13310,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\u0000-\\W]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13086,7 +13356,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13117,6 +13388,7 @@
                   "start": 1,
                   "end": 16,
                   "raw": "[\\u0000-\\u0001]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13160,7 +13432,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13191,6 +13464,7 @@
                   "start": 1,
                   "end": 13,
                   "raw": "[\\u{2-\\u{1}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13274,7 +13548,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13305,6 +13580,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\a-\\z]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13348,7 +13624,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13379,6 +13656,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[0-9--/]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13445,7 +13723,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13476,6 +13755,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\c0-\u001f]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13519,7 +13799,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13550,6 +13831,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\c_]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13578,7 +13860,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13626,6 +13909,7 @@
                     "start": 2,
                     "end": 7,
                     "raw": "[0-9]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -13678,7 +13962,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13726,6 +14011,7 @@
                     "start": 2,
                     "end": 7,
                     "raw": "[0-9]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -13778,7 +14064,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13826,6 +14113,7 @@
                     "start": 2,
                     "end": 10,
                     "raw": "[a-zA-Z]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -13901,7 +14189,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13949,6 +14238,7 @@
                     "start": 2,
                     "end": 10,
                     "raw": "[a-zA-Z]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -14024,7 +14314,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -14072,6 +14363,7 @@
                     "start": 2,
                     "end": 13,
                     "raw": "[0-9a-zA-Z]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -14170,7 +14462,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -14218,6 +14511,7 @@
                     "start": 2,
                     "end": 26,
                     "raw": "[a-zA-Z0-9!-/:-@\\[-`{-~]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -14408,7 +14702,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -14471,6 +14766,7 @@
                             "start": 3,
                             "end": 14,
                             "raw": "[a-zA-Z0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -14574,7 +14870,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -14637,6 +14934,7 @@
                             "start": 3,
                             "end": 14,
                             "raw": "[a-zA-Z0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -14740,7 +15038,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -14803,6 +15102,7 @@
                             "start": 3,
                             "end": 8,
                             "raw": "[0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -14860,7 +15160,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -14908,6 +15209,7 @@
                     "start": 2,
                     "end": 7,
                     "raw": "[0-9]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -14960,7 +15262,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15083,7 +15386,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15186,7 +15490,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15319,7 +15624,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15373,6 +15679,7 @@
                           "start": 3,
                           "end": 8,
                           "raw": "[1-9]",
+                          "unicodeSets": false,
                           "negate": false,
                           "elements": [
                             {
@@ -15415,6 +15722,7 @@
                             "start": 8,
                             "end": 13,
                             "raw": "[0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -15512,6 +15820,7 @@
                               "start": 20,
                               "end": 25,
                               "raw": "[0-9]",
+                              "unicodeSets": false,
                               "negate": false,
                               "elements": [
                                 {
@@ -15570,7 +15879,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15642,6 +15952,7 @@
                           "start": 5,
                           "end": 10,
                           "raw": "[1-9]",
+                          "unicodeSets": false,
                           "negate": false,
                           "elements": [
                             {
@@ -15684,6 +15995,7 @@
                             "start": 10,
                             "end": 15,
                             "raw": "[0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -15781,6 +16093,7 @@
                               "start": 22,
                               "end": 27,
                               "raw": "[0-9]",
+                              "unicodeSets": false,
                               "negate": false,
                               "elements": [
                                 {
@@ -15839,7 +16152,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15887,6 +16201,7 @@
                     "start": 2,
                     "end": 8,
                     "raw": "[ぁ-んー]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -15947,7 +16262,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15995,6 +16311,7 @@
                     "start": 2,
                     "end": 9,
                     "raw": "[ァ-ンヴー]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -16063,7 +16380,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -16111,6 +16429,7 @@
                     "start": 2,
                     "end": 11,
                     "raw": "[ｧ-ﾝﾞﾟ\\-]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -16187,7 +16506,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -16235,6 +16555,7 @@
                     "start": 2,
                     "end": 14,
                     "raw": "[^\\x20-\\x7e]",
+                    "unicodeSets": false,
                     "negate": true,
                     "elements": [
                       {
@@ -16287,7 +16608,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -16335,6 +16657,7 @@
                     "start": 2,
                     "end": 33,
                     "raw": "[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -16592,6 +16915,7 @@
                     "start": 35,
                     "end": 47,
                     "raw": "[a-zA-Z0-9-]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -16689,6 +17013,7 @@
                     "start": 48,
                     "end": 67,
                     "raw": "(?:\\.[a-zA-Z0-9-]+)",
+                    "modifiers": null,
                     "alternatives": [
                       {
                         "type": "Alternative",
@@ -16720,6 +17045,7 @@
                               "start": 53,
                               "end": 65,
                               "raw": "[a-zA-Z0-9-]",
+                              "unicodeSets": false,
                               "negate": false,
                               "elements": [
                                 {
@@ -16831,7 +17157,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -16964,6 +17291,7 @@
                                   "start": 14,
                                   "end": 19,
                                   "raw": "[1-5]",
+                                  "unicodeSets": false,
                                   "negate": false,
                                   "elements": [
                                     {
@@ -17111,6 +17439,7 @@
                             "start": 34,
                             "end": 38,
                             "raw": "[- ]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -17186,6 +17515,7 @@
                             "start": 46,
                             "end": 50,
                             "raw": "[- ]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -17261,6 +17591,7 @@
                             "start": 58,
                             "end": 62,
                             "raw": "[- ]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -17329,6 +17660,7 @@
                   "start": 71,
                   "end": 76,
                   "raw": "[4,7]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -17400,7 +17732,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -17504,7 +17837,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -17535,6 +17869,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\d]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -17563,6 +17898,7 @@
                     "start": 5,
                     "end": 14,
                     "raw": "[\\12-\\14]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -17597,6 +17933,7 @@
                   "start": 18,
                   "end": 23,
                   "raw": "[^\\d]",
+                  "unicodeSets": false,
                   "negate": true,
                   "elements": [
                     {
@@ -17626,7 +17963,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     }
diff --git a/test/fixtures/parser/literal/basic-valid.json b/test/fixtures/parser/literal/basic-valid.json
index d5d0136..80189ea 100644
--- a/test/fixtures/parser/literal/basic-valid.json
+++ b/test/fixtures/parser/literal/basic-valid.json
@@ -65,7 +65,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -163,7 +164,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -235,7 +237,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -337,7 +340,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -397,7 +401,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -482,7 +487,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -542,7 +548,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -627,7 +634,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -706,7 +714,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -785,7 +794,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -864,7 +874,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -941,7 +952,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1026,7 +1038,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1119,7 +1132,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1198,7 +1212,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1277,7 +1292,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1356,7 +1372,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1415,7 +1432,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1474,7 +1492,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1533,7 +1552,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1590,7 +1610,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1655,7 +1676,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1728,7 +1750,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1787,7 +1810,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1852,7 +1876,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1911,7 +1936,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1984,7 +2010,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2043,7 +2070,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2124,7 +2152,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2205,7 +2234,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2264,7 +2294,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2323,7 +2354,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2382,7 +2414,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2449,7 +2482,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2524,7 +2558,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2607,7 +2642,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2666,7 +2702,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2741,7 +2778,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2800,7 +2838,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2883,7 +2922,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -2942,7 +2982,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3033,7 +3074,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3124,7 +3166,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3213,7 +3256,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3262,7 +3306,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3311,7 +3356,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3360,7 +3406,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3409,7 +3456,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3458,7 +3506,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3507,7 +3556,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3555,7 +3605,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3636,7 +3687,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3685,7 +3737,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3747,6 +3800,7 @@
                   "end": 6,
                   "raw": "\\1",
                   "ref": 1,
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -3765,7 +3819,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3797,6 +3852,7 @@
                   "end": 3,
                   "raw": "\\1",
                   "ref": 1,
+                  "ambiguous": false,
                   "resolved": "♻️../1"
                 },
                 {
@@ -3845,7 +3901,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3876,6 +3933,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "(?:a)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -3920,7 +3978,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -3997,7 +4056,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4028,6 +4088,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "(?:a)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -4072,7 +4133,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4386,6 +4448,7 @@
                   "end": 34,
                   "raw": "\\10",
                   "ref": 10,
+                  "ambiguous": false,
                   "resolved": "♻️../9"
                 }
               ]
@@ -4404,7 +4467,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -4733,7 +4797,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5075,6 +5140,7 @@
                   "end": 37,
                   "raw": "\\11",
                   "ref": 11,
+                  "ambiguous": false,
                   "resolved": "♻️../10"
                 }
               ]
@@ -5093,7 +5159,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5124,6 +5191,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "(?:a)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -5160,7 +5228,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5210,7 +5279,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5260,7 +5330,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5310,7 +5381,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5360,7 +5432,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5410,7 +5483,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5460,7 +5534,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5509,7 +5584,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5558,7 +5634,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5607,7 +5684,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5656,7 +5734,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5705,7 +5784,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5754,7 +5834,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5803,7 +5884,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5868,7 +5950,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5925,7 +6008,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -5974,7 +6058,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6023,7 +6108,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6080,7 +6166,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6145,7 +6232,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6218,7 +6306,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6267,7 +6356,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6324,7 +6414,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6381,7 +6472,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6446,7 +6538,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6519,7 +6612,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6592,7 +6686,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6651,7 +6746,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6764,7 +6860,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6823,7 +6920,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6882,7 +6980,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6931,7 +7030,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -6988,7 +7088,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7037,7 +7138,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7086,7 +7188,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7135,7 +7238,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7184,7 +7288,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7233,7 +7338,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7282,7 +7388,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7331,7 +7438,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7380,7 +7488,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7429,7 +7538,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7478,7 +7588,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7527,7 +7638,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7576,7 +7688,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7625,7 +7738,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7674,7 +7788,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7705,6 +7820,7 @@
                   "start": 1,
                   "end": 3,
                   "raw": "[]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": []
                 }
@@ -7724,7 +7840,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7755,6 +7872,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[^-a-b-]",
+                  "unicodeSets": false,
                   "negate": true,
                   "elements": [
                     {
@@ -7814,7 +7932,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7845,6 +7964,7 @@
                   "start": 1,
                   "end": 4,
                   "raw": "[-]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7873,7 +7993,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7904,6 +8025,7 @@
                   "start": 1,
                   "end": 4,
                   "raw": "[a]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7932,7 +8054,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -7963,6 +8086,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[--]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -7999,7 +8123,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8030,6 +8155,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[-a]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8066,7 +8192,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8097,6 +8224,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[-a-]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8141,7 +8269,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8172,6 +8301,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[a-]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8208,7 +8338,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8239,6 +8370,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[a-b]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8282,7 +8414,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8313,6 +8446,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[-a-b-]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8372,7 +8506,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8403,6 +8538,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[---]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8446,7 +8582,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8477,6 +8614,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[a-b--/]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8543,7 +8681,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8574,6 +8713,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\b-\\n]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8617,7 +8757,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8648,6 +8789,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[b\\-a]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8692,7 +8834,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8723,6 +8866,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\d]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8752,7 +8896,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8783,6 +8928,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\D]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8812,7 +8958,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8843,6 +8990,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\s]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8872,7 +9020,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8903,6 +9052,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\S]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8932,7 +9082,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -8963,6 +9114,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\w]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -8992,7 +9144,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9023,6 +9176,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\W]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9052,7 +9206,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9083,6 +9238,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\f]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9111,7 +9267,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9142,6 +9299,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\n]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9170,7 +9328,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9201,6 +9360,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\r]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9229,7 +9389,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9260,6 +9421,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\t]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9288,7 +9450,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9319,6 +9482,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\v]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9347,7 +9511,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9378,6 +9543,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\cA]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9406,7 +9572,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9437,6 +9604,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\cz]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9465,7 +9633,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9496,6 +9665,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\c1]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9524,7 +9694,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9555,6 +9726,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\c]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9591,7 +9763,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9622,6 +9795,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\0]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9650,7 +9824,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9681,6 +9856,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\x]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9709,7 +9885,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9740,6 +9917,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\xz]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9776,7 +9954,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9807,6 +9986,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\x1]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9843,7 +10023,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9874,6 +10055,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[\\x12]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9902,7 +10084,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -9933,6 +10116,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\x123]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -9969,7 +10153,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10000,6 +10185,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\u]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10028,7 +10214,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10059,6 +10246,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\u1]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10095,7 +10283,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10126,6 +10315,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[\\u12]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10170,7 +10360,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10201,6 +10392,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\u123]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10253,7 +10445,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10284,6 +10477,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[\\u1234]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10312,7 +10506,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10343,6 +10538,7 @@
                   "start": 1,
                   "end": 10,
                   "raw": "[\\u12345]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10379,7 +10575,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10410,6 +10607,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\u{]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10446,7 +10644,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10477,6 +10676,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[\\u{z]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10521,7 +10721,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10552,6 +10753,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\u{a}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10604,7 +10806,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10635,6 +10838,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\u{20]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10687,7 +10891,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10718,6 +10923,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[\\u{20}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10778,7 +10984,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10809,6 +11016,7 @@
                   "start": 1,
                   "end": 13,
                   "raw": "[\\u{10FFFF}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -10901,7 +11109,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -10932,6 +11141,7 @@
                   "start": 1,
                   "end": 13,
                   "raw": "[\\u{110000}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11024,7 +11234,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11055,6 +11266,7 @@
                   "start": 1,
                   "end": 15,
                   "raw": "[\\u{00000001}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11163,7 +11375,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11194,6 +11407,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\77]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11222,7 +11436,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11253,6 +11468,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[\\377]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11281,7 +11497,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11312,6 +11529,7 @@
                   "start": 1,
                   "end": 7,
                   "raw": "[\\400]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11348,7 +11566,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11379,6 +11598,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\^]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11407,7 +11627,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11438,6 +11659,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\$]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11466,7 +11688,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11497,6 +11720,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\.]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11525,7 +11749,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11556,6 +11781,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\+]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11584,7 +11810,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11615,6 +11842,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\?]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11643,7 +11871,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11674,6 +11903,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\(]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11702,7 +11932,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11733,6 +11964,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\)]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11761,7 +11993,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11792,6 +12025,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\[]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11820,7 +12054,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11851,6 +12086,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\]]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11879,7 +12115,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11910,6 +12147,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\{]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11938,7 +12176,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -11969,6 +12208,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -11997,7 +12237,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12028,6 +12269,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\|]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12056,7 +12298,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12087,6 +12330,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\/]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12115,7 +12359,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12146,6 +12391,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\a]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12174,7 +12420,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12205,6 +12452,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\d-\\uFFFF]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12250,7 +12498,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12281,6 +12530,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\D-\\uFFFF]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12326,7 +12576,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12357,6 +12608,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\s-\\uFFFF]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12402,7 +12654,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12433,6 +12686,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\S-\\uFFFF]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12478,7 +12732,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12509,6 +12764,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\w-\\uFFFF]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12554,7 +12810,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12585,6 +12842,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\W-\\uFFFF]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12630,7 +12888,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12661,6 +12920,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\u0000-\\d]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12706,7 +12966,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12737,6 +12998,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\u0000-\\D]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12782,7 +13044,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12813,6 +13076,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\u0000-\\s]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12858,7 +13122,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12889,6 +13154,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\u0000-\\S]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -12934,7 +13200,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -12965,6 +13232,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\u0000-\\w]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13010,7 +13278,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13041,6 +13310,7 @@
                   "start": 1,
                   "end": 12,
                   "raw": "[\\u0000-\\W]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13086,7 +13356,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13117,6 +13388,7 @@
                   "start": 1,
                   "end": 16,
                   "raw": "[\\u0000-\\u0001]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13160,7 +13432,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13191,6 +13464,7 @@
                   "start": 1,
                   "end": 13,
                   "raw": "[\\u{2-\\u{1}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13274,7 +13548,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13305,6 +13580,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\a-\\z]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13348,7 +13624,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13379,6 +13656,7 @@
                   "start": 1,
                   "end": 9,
                   "raw": "[0-9--/]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13445,7 +13723,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13476,6 +13755,7 @@
                   "start": 1,
                   "end": 8,
                   "raw": "[\\c0-\u001f]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13519,7 +13799,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13550,6 +13831,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "[\\c_]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -13578,7 +13860,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13626,6 +13909,7 @@
                     "start": 2,
                     "end": 7,
                     "raw": "[0-9]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -13678,7 +13962,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13726,6 +14011,7 @@
                     "start": 2,
                     "end": 7,
                     "raw": "[0-9]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -13778,7 +14064,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13826,6 +14113,7 @@
                     "start": 2,
                     "end": 10,
                     "raw": "[a-zA-Z]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -13901,7 +14189,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -13949,6 +14238,7 @@
                     "start": 2,
                     "end": 10,
                     "raw": "[a-zA-Z]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -14024,7 +14314,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -14072,6 +14363,7 @@
                     "start": 2,
                     "end": 13,
                     "raw": "[0-9a-zA-Z]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -14170,7 +14462,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -14218,6 +14511,7 @@
                     "start": 2,
                     "end": 26,
                     "raw": "[a-zA-Z0-9!-/:-@\\[-`{-~]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -14408,7 +14702,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -14471,6 +14766,7 @@
                             "start": 3,
                             "end": 14,
                             "raw": "[a-zA-Z0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -14574,7 +14870,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -14637,6 +14934,7 @@
                             "start": 3,
                             "end": 14,
                             "raw": "[a-zA-Z0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -14740,7 +15038,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -14803,6 +15102,7 @@
                             "start": 3,
                             "end": 8,
                             "raw": "[0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -14860,7 +15160,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -14908,6 +15209,7 @@
                     "start": 2,
                     "end": 7,
                     "raw": "[0-9]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -14960,7 +15262,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15083,7 +15386,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15186,7 +15490,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15319,7 +15624,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15373,6 +15679,7 @@
                           "start": 3,
                           "end": 8,
                           "raw": "[1-9]",
+                          "unicodeSets": false,
                           "negate": false,
                           "elements": [
                             {
@@ -15415,6 +15722,7 @@
                             "start": 8,
                             "end": 13,
                             "raw": "[0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -15512,6 +15820,7 @@
                               "start": 20,
                               "end": 25,
                               "raw": "[0-9]",
+                              "unicodeSets": false,
                               "negate": false,
                               "elements": [
                                 {
@@ -15570,7 +15879,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15642,6 +15952,7 @@
                           "start": 5,
                           "end": 10,
                           "raw": "[1-9]",
+                          "unicodeSets": false,
                           "negate": false,
                           "elements": [
                             {
@@ -15684,6 +15995,7 @@
                             "start": 10,
                             "end": 15,
                             "raw": "[0-9]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -15781,6 +16093,7 @@
                               "start": 22,
                               "end": 27,
                               "raw": "[0-9]",
+                              "unicodeSets": false,
                               "negate": false,
                               "elements": [
                                 {
@@ -15839,7 +16152,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15887,6 +16201,7 @@
                     "start": 2,
                     "end": 8,
                     "raw": "[ぁ-んー]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -15947,7 +16262,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -15995,6 +16311,7 @@
                     "start": 2,
                     "end": 9,
                     "raw": "[ァ-ンヴー]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -16063,7 +16380,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -16111,6 +16429,7 @@
                     "start": 2,
                     "end": 11,
                     "raw": "[ｧ-ﾝﾞﾟ\\-]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -16187,7 +16506,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -16235,6 +16555,7 @@
                     "start": 2,
                     "end": 14,
                     "raw": "[^\\x20-\\x7e]",
+                    "unicodeSets": false,
                     "negate": true,
                     "elements": [
                       {
@@ -16287,7 +16608,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -16335,6 +16657,7 @@
                     "start": 2,
                     "end": 33,
                     "raw": "[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -16592,6 +16915,7 @@
                     "start": 35,
                     "end": 47,
                     "raw": "[a-zA-Z0-9-]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -16689,6 +17013,7 @@
                     "start": 48,
                     "end": 67,
                     "raw": "(?:\\.[a-zA-Z0-9-]+)",
+                    "modifiers": null,
                     "alternatives": [
                       {
                         "type": "Alternative",
@@ -16720,6 +17045,7 @@
                               "start": 53,
                               "end": 65,
                               "raw": "[a-zA-Z0-9-]",
+                              "unicodeSets": false,
                               "negate": false,
                               "elements": [
                                 {
@@ -16831,7 +17157,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -16964,6 +17291,7 @@
                                   "start": 14,
                                   "end": 19,
                                   "raw": "[1-5]",
+                                  "unicodeSets": false,
                                   "negate": false,
                                   "elements": [
                                     {
@@ -17111,6 +17439,7 @@
                             "start": 34,
                             "end": 38,
                             "raw": "[- ]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -17186,6 +17515,7 @@
                             "start": 46,
                             "end": 50,
                             "raw": "[- ]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -17261,6 +17591,7 @@
                             "start": 58,
                             "end": 62,
                             "raw": "[- ]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -17329,6 +17660,7 @@
                   "start": 71,
                   "end": 76,
                   "raw": "[4,7]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -17400,7 +17732,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -17504,7 +17837,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -17535,6 +17869,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "[\\d]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -17563,6 +17898,7 @@
                     "start": 5,
                     "end": 14,
                     "raw": "[\\12-\\14]",
+                    "unicodeSets": false,
                     "negate": false,
                     "elements": [
                       {
@@ -17597,6 +17933,7 @@
                   "start": 18,
                   "end": 23,
                   "raw": "[^\\d]",
+                  "unicodeSets": false,
                   "negate": true,
                   "elements": [
                     {
@@ -17626,7 +17963,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -17681,6 +18019,7 @@
                             "start": 2,
                             "end": 6,
                             "raw": "[a ]",
+                            "unicodeSets": false,
                             "negate": false,
                             "elements": [
                               {
@@ -17741,7 +18080,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     }
diff --git a/test/fixtures/parser/literal/class-set-expression-escape-valid-2024.json b/test/fixtures/parser/literal/class-set-expression-escape-valid-2024.json
new file mode 100644
index 0000000..fb01857
--- /dev/null
+++ b/test/fixtures/parser/literal/class-set-expression-escape-valid-2024.json
@@ -0,0 +1,234 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/[\\&\\-\\!\\#\\%\\,\\:\\;\\<\\=\\>\\@\\`\\~]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/[\\&\\-\\!\\#\\%\\,\\:\\;\\<\\=\\>\\@\\`\\~]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "[\\&\\-\\!\\#\\%\\,\\:\\;\\<\\=\\>\\@\\`\\~]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "[\\&\\-\\!\\#\\%\\,\\:\\;\\<\\=\\>\\@\\`\\~]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 31,
+                  "raw": "[\\&\\-\\!\\#\\%\\,\\:\\;\\<\\=\\>\\@\\`\\~]",
+                  "unicodeSets": true,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "\\&",
+                      "value": 38
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "\\-",
+                      "value": 45
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "\\!",
+                      "value": 33
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 10,
+                      "raw": "\\#",
+                      "value": 35
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 12,
+                      "raw": "\\%",
+                      "value": 37
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 14,
+                      "raw": "\\,",
+                      "value": 44
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 16,
+                      "raw": "\\:",
+                      "value": 58
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 18,
+                      "raw": "\\;",
+                      "value": 59
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 20,
+                      "raw": "\\<",
+                      "value": 60
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 20,
+                      "end": 22,
+                      "raw": "\\=",
+                      "value": 61
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 22,
+                      "end": 24,
+                      "raw": "\\>",
+                      "value": 62
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 24,
+                      "end": 26,
+                      "raw": "\\@",
+                      "value": 64
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 26,
+                      "end": 28,
+                      "raw": "\\`",
+                      "value": 96
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 28,
+                      "end": 30,
+                      "raw": "\\~",
+                      "value": 126
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\b]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/[\\b]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "[\\b]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "[\\b]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[\\b]",
+                  "unicodeSets": true,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "\\b",
+                      "value": 8
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 7,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/class-set-expression-intersection-invalid-2024.json b/test/fixtures/parser/literal/class-set-expression-intersection-invalid-2024.json
new file mode 100644
index 0000000..dde8118
--- /dev/null
+++ b/test/fixtures/parser/literal/class-set-expression-intersection-invalid-2024.json
@@ -0,0 +1,14 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/[^[\\q{abc|d|e|f}&&\\q{def}]]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^[\\q{abc|d|e|f}&&\\q{def}]]/v: Negated character class may contain strings",
+        "index": 28
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/class-set-expression-intersection-valid-2024.json b/test/fixtures/parser/literal/class-set-expression-intersection-valid-2024.json
new file mode 100644
index 0000000..78b98cd
--- /dev/null
+++ b/test/fixtures/parser/literal/class-set-expression-intersection-valid-2024.json
@@ -0,0 +1,2626 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/[A&&B]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[A&&B]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "[A&&B]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "[A&&B]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "[A&&B]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 6,
+                    "raw": "A&&B",
+                    "left": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "A",
+                      "value": 65
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "B",
+                      "value": 66
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[A&&B&&C]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/[A&&B&&C]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "[A&&B&&C]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "[A&&B&&C]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "[A&&B&&C]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "A&&B&&C",
+                    "left": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "A&&B",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "A",
+                        "value": 65
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "B",
+                        "value": 66
+                      }
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "C",
+                      "value": 67
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[^A&&B]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[^A&&B]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[^A&&B]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[^A&&B]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[^A&&B]",
+                  "negate": true,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "A&&B",
+                    "left": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "A",
+                      "value": 65
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "B",
+                      "value": 66
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[A&&B]?/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[A&&B]?/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[A&&B]?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[A&&B]?",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[A&&B]?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 7,
+                    "raw": "[A&&B]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "A&&B",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "A",
+                        "value": 65
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "B",
+                        "value": 66
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\w&&[\\(\\)]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/[\\w&&[\\(\\)]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "[\\w&&[\\(\\)]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "[\\w&&[\\(\\)]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "[\\w&&[\\(\\)]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\w&&[\\(\\)]",
+                    "left": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "\\w",
+                      "kind": "word",
+                      "negate": false
+                    },
+                    "right": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 12,
+                      "raw": "[\\(\\)]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 9,
+                          "raw": "\\(",
+                          "value": 40
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 11,
+                          "raw": "\\)",
+                          "value": 41
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[[A&&B]&&C]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[[A&&B]&&C]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[[A&&B]&&C]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[[A&&B]&&C]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "[[A&&B]&&C]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "[A&&B]&&C",
+                    "left": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "[A&&B]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassIntersection",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 7,
+                        "raw": "A&&B",
+                        "left": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "A",
+                          "value": 65
+                        },
+                        "right": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "B",
+                          "value": 66
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 10,
+                      "end": 11,
+                      "raw": "C",
+                      "value": 67
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[[A--B]&&C]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[[A--B]&&C]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[[A--B]&&C]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[[A--B]&&C]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "[[A--B]&&C]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "[A--B]&&C",
+                    "left": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "[A--B]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassSubtraction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 7,
+                        "raw": "A--B",
+                        "left": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "A",
+                          "value": 65
+                        },
+                        "right": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "B",
+                          "value": 66
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 10,
+                      "end": 11,
+                      "raw": "C",
+                      "value": 67
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[[A&&B]--C]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[[A&&B]--C]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[[A&&B]--C]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[[A&&B]--C]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "[[A&&B]--C]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "[A&&B]--C",
+                    "left": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "[A&&B]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassIntersection",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 7,
+                        "raw": "A&&B",
+                        "left": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "A",
+                          "value": 65
+                        },
+                        "right": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "B",
+                          "value": 66
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 10,
+                      "end": 11,
+                      "raw": "C",
+                      "value": 67
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[A&&[B&&C]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[A&&[B&&C]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[A&&[B&&C]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[A&&[B&&C]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "[A&&[B&&C]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "A&&[B&&C]",
+                    "left": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "A",
+                      "value": 65
+                    },
+                    "right": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 11,
+                      "raw": "[B&&C]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassIntersection",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 10,
+                        "raw": "B&&C",
+                        "left": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "B",
+                          "value": 66
+                        },
+                        "right": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "C",
+                          "value": 67
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[A&&[B--C]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[A&&[B--C]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[A&&[B--C]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[A&&[B--C]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "[A&&[B--C]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "A&&[B--C]",
+                    "left": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "A",
+                      "value": 65
+                    },
+                    "right": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 11,
+                      "raw": "[B--C]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassSubtraction",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 10,
+                        "raw": "B--C",
+                        "left": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "B",
+                          "value": 66
+                        },
+                        "right": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "C",
+                          "value": 67
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\q{abc|def|ghi}&&\\q{def}]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/[\\q{abc|def|ghi}&&\\q{def}]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "[\\q{abc|def|ghi}&&\\q{def}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "[\\q{abc|def|ghi}&&\\q{def}]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 27,
+                  "raw": "[\\q{abc|def|ghi}&&\\q{def}]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\q{abc|def|ghi}&&\\q{def}",
+                    "left": {
+                      "type": "ClassStringDisjunction",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 17,
+                      "raw": "\\q{abc|def|ghi}",
+                      "alternatives": [
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 8,
+                          "raw": "abc",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 5,
+                              "end": 6,
+                              "raw": "a",
+                              "value": 97
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "b",
+                              "value": 98
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "c",
+                              "value": 99
+                            }
+                          ]
+                        },
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 12,
+                          "raw": "def",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "d",
+                              "value": 100
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 10,
+                              "end": 11,
+                              "raw": "e",
+                              "value": 101
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "f",
+                              "value": 102
+                            }
+                          ]
+                        },
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 16,
+                          "raw": "ghi",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 13,
+                              "end": 14,
+                              "raw": "g",
+                              "value": 103
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 14,
+                              "end": 15,
+                              "raw": "h",
+                              "value": 104
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 15,
+                              "end": 16,
+                              "raw": "i",
+                              "value": 105
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    "right": {
+                      "type": "ClassStringDisjunction",
+                      "parent": "♻️..",
+                      "start": 19,
+                      "end": 26,
+                      "raw": "\\q{def}",
+                      "alternatives": [
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 25,
+                          "raw": "def",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 22,
+                              "end": 23,
+                              "raw": "d",
+                              "value": 100
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 23,
+                              "end": 24,
+                              "raw": "e",
+                              "value": 101
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 24,
+                              "end": 25,
+                              "raw": "f",
+                              "value": 102
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[^[\\q{a|b|c}&&\\q{b}]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/[^[\\q{a|b|c}&&\\q{b}]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "[^[\\q{a|b|c}&&\\q{b}]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "[^[\\q{a|b|c}&&\\q{b}]]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 22,
+                  "raw": "[^[\\q{a|b|c}&&\\q{b}]]",
+                  "unicodeSets": true,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 21,
+                      "raw": "[\\q{a|b|c}&&\\q{b}]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassIntersection",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 20,
+                        "raw": "\\q{a|b|c}&&\\q{b}",
+                        "left": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 13,
+                          "raw": "\\q{a|b|c}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "a",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "b",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "c",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        "right": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 15,
+                          "end": 20,
+                          "raw": "\\q{b}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 18,
+                              "end": 19,
+                              "raw": "b",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 18,
+                                  "end": 19,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[^[\\q{abc|d|e|f}&&\\q{d|e|f}]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/[^[\\q{abc|d|e|f}&&\\q{d|e|f}]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "[^[\\q{abc|d|e|f}&&\\q{d|e|f}]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "[^[\\q{abc|d|e|f}&&\\q{d|e|f}]]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 30,
+                  "raw": "[^[\\q{abc|d|e|f}&&\\q{d|e|f}]]",
+                  "unicodeSets": true,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 29,
+                      "raw": "[\\q{abc|d|e|f}&&\\q{d|e|f}]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassIntersection",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 28,
+                        "raw": "\\q{abc|d|e|f}&&\\q{d|e|f}",
+                        "left": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 17,
+                          "raw": "\\q{abc|d|e|f}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 10,
+                              "raw": "abc",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 9,
+                                  "raw": "b",
+                                  "value": 98
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "d",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "d",
+                                  "value": 100
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 13,
+                              "end": 14,
+                              "raw": "e",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "e",
+                                  "value": 101
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 15,
+                              "end": 16,
+                              "raw": "f",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 15,
+                                  "end": 16,
+                                  "raw": "f",
+                                  "value": 102
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        "right": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 19,
+                          "end": 28,
+                          "raw": "\\q{d|e|f}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 22,
+                              "end": 23,
+                              "raw": "d",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 22,
+                                  "end": 23,
+                                  "raw": "d",
+                                  "value": 100
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 24,
+                              "end": 25,
+                              "raw": "e",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 24,
+                                  "end": 25,
+                                  "raw": "e",
+                                  "value": 101
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 26,
+                              "end": 27,
+                              "raw": "f",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 26,
+                                  "end": 27,
+                                  "raw": "f",
+                                  "value": 102
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[^[\\q{a|b|c}&&\\q{def}]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/[^[\\q{a|b|c}&&\\q{def}]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "[^[\\q{a|b|c}&&\\q{def}]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "[^[\\q{a|b|c}&&\\q{def}]]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 24,
+                  "raw": "[^[\\q{a|b|c}&&\\q{def}]]",
+                  "unicodeSets": true,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 23,
+                      "raw": "[\\q{a|b|c}&&\\q{def}]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassIntersection",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 22,
+                        "raw": "\\q{a|b|c}&&\\q{def}",
+                        "left": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 13,
+                          "raw": "\\q{a|b|c}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "a",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "b",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "c",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        "right": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 15,
+                          "end": 22,
+                          "raw": "\\q{def}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 18,
+                              "end": 21,
+                              "raw": "def",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 18,
+                                  "end": 19,
+                                  "raw": "d",
+                                  "value": 100
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 19,
+                                  "end": 20,
+                                  "raw": "e",
+                                  "value": 101
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 20,
+                                  "end": 21,
+                                  "raw": "f",
+                                  "value": 102
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[^[\\q{a|b|c}&&\\q{}]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/[^[\\q{a|b|c}&&\\q{}]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "[^[\\q{a|b|c}&&\\q{}]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "[^[\\q{a|b|c}&&\\q{}]]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 21,
+                  "raw": "[^[\\q{a|b|c}&&\\q{}]]",
+                  "unicodeSets": true,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 20,
+                      "raw": "[\\q{a|b|c}&&\\q{}]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassIntersection",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 19,
+                        "raw": "\\q{a|b|c}&&\\q{}",
+                        "left": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 13,
+                          "raw": "\\q{a|b|c}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "a",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "b",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "c",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        "right": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 15,
+                          "end": 19,
+                          "raw": "\\q{}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 18,
+                              "end": 18,
+                              "raw": "",
+                              "elements": []
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[^[\\q{}&&\\q{d|e|f}]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/[^[\\q{}&&\\q{d|e|f}]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "[^[\\q{}&&\\q{d|e|f}]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "[^[\\q{}&&\\q{d|e|f}]]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 21,
+                  "raw": "[^[\\q{}&&\\q{d|e|f}]]",
+                  "unicodeSets": true,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 20,
+                      "raw": "[\\q{}&&\\q{d|e|f}]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassIntersection",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 19,
+                        "raw": "\\q{}&&\\q{d|e|f}",
+                        "left": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 8,
+                          "raw": "\\q{}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 7,
+                              "raw": "",
+                              "elements": []
+                            }
+                          ]
+                        },
+                        "right": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 10,
+                          "end": 19,
+                          "raw": "\\q{d|e|f}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 13,
+                              "end": 14,
+                              "raw": "d",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "d",
+                                  "value": 100
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 15,
+                              "end": 16,
+                              "raw": "e",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 15,
+                                  "end": 16,
+                                  "raw": "e",
+                                  "value": 101
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 17,
+                              "end": 18,
+                              "raw": "f",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 17,
+                                  "end": 18,
+                                  "raw": "f",
+                                  "value": 102
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[a&&b&&[c]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[a&&b&&[c]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[a&&b&&[c]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[a&&b&&[c]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "[a&&b&&[c]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "a&&b&&[c]",
+                    "left": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "a&&b",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "b",
+                        "value": 98
+                      }
+                    },
+                    "right": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 8,
+                      "end": 11,
+                      "raw": "[c]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[a&&b&&[^c]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/[a&&b&&[^c]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "[a&&b&&[^c]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "[a&&b&&[^c]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "[a&&b&&[^c]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "a&&b&&[^c]",
+                    "left": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "a&&b",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "b",
+                        "value": 98
+                      }
+                    },
+                    "right": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 8,
+                      "end": 12,
+                      "raw": "[^c]",
+                      "unicodeSets": true,
+                      "negate": true,
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[a--b--[c]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[a--b--[c]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[a--b--[c]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[a--b--[c]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "[a--b--[c]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "a--b--[c]",
+                    "left": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "a--b",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "b",
+                        "value": 98
+                      }
+                    },
+                    "right": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 8,
+                      "end": 11,
+                      "raw": "[c]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[a--b--[^c]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/[a--b--[^c]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "[a--b--[^c]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "[a--b--[^c]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "[a--b--[^c]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "a--b--[^c]",
+                    "left": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "a--b",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "b",
+                        "value": 98
+                      }
+                    },
+                    "right": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 8,
+                      "end": 12,
+                      "raw": "[^c]",
+                      "unicodeSets": true,
+                      "negate": true,
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[a&&b&&[c&&d&&e]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/[a&&b&&[c&&d&&e]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "[a&&b&&[c&&d&&e]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "[a&&b&&[c&&d&&e]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 18,
+                  "raw": "[a&&b&&[c&&d&&e]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "a&&b&&[c&&d&&e]",
+                    "left": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "a&&b",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "b",
+                        "value": 98
+                      }
+                    },
+                    "right": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 8,
+                      "end": 17,
+                      "raw": "[c&&d&&e]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassIntersection",
+                        "parent": "♻️..",
+                        "start": 9,
+                        "end": 16,
+                        "raw": "c&&d&&e",
+                        "left": {
+                          "type": "ClassIntersection",
+                          "parent": "♻️..",
+                          "start": 9,
+                          "end": 13,
+                          "raw": "c&&d",
+                          "left": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "c",
+                            "value": 99
+                          },
+                          "right": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 12,
+                            "end": 13,
+                            "raw": "d",
+                            "value": 100
+                          }
+                        },
+                        "right": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 15,
+                          "end": 16,
+                          "raw": "e",
+                          "value": 101
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[a&&b&&[c--d--[e&&f&&g]]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/[a&&b&&[c--d--[e&&f&&g]]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "[a&&b&&[c--d--[e&&f&&g]]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "[a&&b&&[c--d--[e&&f&&g]]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 26,
+                  "raw": "[a&&b&&[c--d--[e&&f&&g]]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "a&&b&&[c--d--[e&&f&&g]]",
+                    "left": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "a&&b",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "b",
+                        "value": 98
+                      }
+                    },
+                    "right": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 8,
+                      "end": 25,
+                      "raw": "[c--d--[e&&f&&g]]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassSubtraction",
+                        "parent": "♻️..",
+                        "start": 9,
+                        "end": 24,
+                        "raw": "c--d--[e&&f&&g]",
+                        "left": {
+                          "type": "ClassSubtraction",
+                          "parent": "♻️..",
+                          "start": 9,
+                          "end": 13,
+                          "raw": "c--d",
+                          "left": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "c",
+                            "value": 99
+                          },
+                          "right": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 12,
+                            "end": 13,
+                            "raw": "d",
+                            "value": 100
+                          }
+                        },
+                        "right": {
+                          "type": "ExpressionCharacterClass",
+                          "parent": "♻️..",
+                          "start": 15,
+                          "end": 24,
+                          "raw": "[e&&f&&g]",
+                          "negate": false,
+                          "expression": {
+                            "type": "ClassIntersection",
+                            "parent": "♻️..",
+                            "start": 16,
+                            "end": 23,
+                            "raw": "e&&f&&g",
+                            "left": {
+                              "type": "ClassIntersection",
+                              "parent": "♻️..",
+                              "start": 16,
+                              "end": 20,
+                              "raw": "e&&f",
+                              "left": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 16,
+                                "end": 17,
+                                "raw": "e",
+                                "value": 101
+                              },
+                              "right": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 19,
+                                "end": 20,
+                                "raw": "f",
+                                "value": 102
+                              }
+                            },
+                            "right": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 22,
+                              "end": 23,
+                              "raw": "g",
+                              "value": 103
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/class-set-expression-invalid-2024.json b/test/fixtures/parser/literal/class-set-expression-invalid-2024.json
new file mode 100644
index 0000000..b362e3c
--- /dev/null
+++ b/test/fixtures/parser/literal/class-set-expression-invalid-2024.json
@@ -0,0 +1,332 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/[(]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[(]/v: Invalid character in character class",
+        "index": 2
+      }
+    },
+    "/[)]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[)]/v: Invalid character in character class",
+        "index": 2
+      }
+    },
+    "/[[]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[[]/v: Unterminated character class",
+        "index": 4
+      }
+    },
+    "/[{]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[{]/v: Invalid character in character class",
+        "index": 2
+      }
+    },
+    "/[}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[}]/v: Invalid character in character class",
+        "index": 2
+      }
+    },
+    "/[/]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[/]/v: Invalid character in character class",
+        "index": 2
+      }
+    },
+    "/[-]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[-]/v: Invalid character in character class",
+        "index": 2
+      }
+    },
+    "/[|]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[|]/v: Invalid character in character class",
+        "index": 2
+      }
+    },
+    "/[&&]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[&&]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[!!]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[!!]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[##]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[##]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[$$]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[$$]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[%%]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[%%]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[**]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[**]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[++]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[++]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[,,]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[,,]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[..]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[..]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[::]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[::]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[;;]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[;;]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[<<]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[<<]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[==]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[==]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[>>]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[>>]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[??]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[??]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[@@]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[@@]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[ ^^]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[ ^^]/v: Invalid character in character class",
+        "index": 3
+      }
+    },
+    "/[``]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[``]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[~~]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[~~]/v: Invalid set operation in character class",
+        "index": 2
+      }
+    },
+    "/[A-]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[A-]/v: Invalid character in character class",
+        "index": 3
+      }
+    },
+    "/[A-/v": {
+      "error": {
+        "message": "Invalid regular expression: /[A-/v: Unterminated character class",
+        "index": 6
+      }
+    },
+    "/[A--\\q{abc|def]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[A--\\q{abc|def]/v: Unterminated class string disjunction",
+        "index": 15
+      }
+    },
+    "/[A**]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[A**]/v: Invalid character in character class",
+        "index": 3
+      }
+    },
+    "/[\\B]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[\\B]/v: Invalid escape",
+        "index": 3
+      }
+    },
+    "/[[/v": {
+      "error": {
+        "message": "Invalid regular expression: /[[/v: Unterminated character class",
+        "index": 5
+      }
+    },
+    "/[[a/v": {
+      "error": {
+        "message": "Invalid regular expression: /[[a/v: Unterminated character class",
+        "index": 6
+      }
+    },
+    "/[[a-/v": {
+      "error": {
+        "message": "Invalid regular expression: /[[a-/v: Unterminated character class",
+        "index": 7
+      }
+    },
+    "/[[^a/v": {
+      "error": {
+        "message": "Invalid regular expression: /[[^a/v: Unterminated character class",
+        "index": 7
+      }
+    },
+    "/[[[a]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[[[a]/v: Unterminated character class",
+        "index": 6
+      }
+    },
+    "/[[[a]]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[[[a]]/v: Unterminated character class",
+        "index": 7
+      }
+    },
+    "/[^\\p{Basic_Emoji}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^\\p{Basic_Emoji}]/v: Negated character class may contain strings",
+        "index": 19
+      }
+    },
+    "/[^\\q{}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^\\q{}]/v: Negated character class may contain strings",
+        "index": 8
+      }
+    },
+    "/[^\\q{ab}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^\\q{ab}]/v: Negated character class may contain strings",
+        "index": 10
+      }
+    },
+    "/[^\\q{a|bc}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^\\q{a|bc}]/v: Negated character class may contain strings",
+        "index": 12
+      }
+    },
+    "/[[^\\p{Basic_Emoji}]]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[[^\\p{Basic_Emoji}]]/v: Negated character class may contain strings",
+        "index": 20
+      }
+    },
+    "/[[^\\q{}]]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[[^\\q{}]]/v: Negated character class may contain strings",
+        "index": 9
+      }
+    },
+    "/[A&&&B]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[A&&&B]/v: Invalid character in character class",
+        "index": 5
+      }
+    },
+    "/[A&&BC]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[A&&BC]/v: Invalid character in character class",
+        "index": 6
+      }
+    },
+    "/[A--BC]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[A--BC]/v: Invalid character in character class",
+        "index": 6
+      }
+    },
+    "/[A&&]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[A&&]/v: Invalid character in character class",
+        "index": 5
+      }
+    },
+    "/[A--]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[A--]/v: Invalid character in character class",
+        "index": 5
+      }
+    },
+    "/[b-a]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[b-a]/v: Range out of order in character class",
+        "index": 5
+      }
+    },
+    "/[a-\\w]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[a-\\w]/v: Invalid character in character class",
+        "index": 3
+      }
+    },
+    "/[a-&&]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[a-&&]/v: Invalid character in character class",
+        "index": 3
+      }
+    },
+    "/[a-b-c]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[a-b-c]/v: Invalid character in character class",
+        "index": 5
+      }
+    },
+    "/\\q{a}/v": {
+      "error": {
+        "message": "Invalid regular expression: /\\q{a}/v: Invalid escape",
+        "index": 2
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/class-set-expression-proposal-regexp-v-flag-2024.json b/test/fixtures/parser/literal/class-set-expression-proposal-regexp-v-flag-2024.json
new file mode 100644
index 0000000..2aaa4f3
--- /dev/null
+++ b/test/fixtures/parser/literal/class-set-expression-proposal-regexp-v-flag-2024.json
@@ -0,0 +1,1618 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/[A&&B]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[A&&B]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "[A&&B]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "[A&&B]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "[A&&B]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 6,
+                    "raw": "A&&B",
+                    "left": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "A",
+                      "value": 65
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "B",
+                      "value": 66
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[A--[0-9]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/[A--[0-9]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "[A--[0-9]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "[A--[0-9]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "[A--[0-9]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "A--[0-9]",
+                    "left": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "A",
+                      "value": 65
+                    },
+                    "right": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 10,
+                      "raw": "[0-9]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "CharacterClassRange",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 9,
+                          "raw": "0-9",
+                          "min": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "value": 48
+                          },
+                          "max": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "9",
+                            "value": 57
+                          }
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\p{Decimal_Number}--[0-9]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/[\\p{Decimal_Number}--[0-9]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "[\\p{Decimal_Number}--[0-9]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "[\\p{Decimal_Number}--[0-9]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 28,
+                  "raw": "[\\p{Decimal_Number}--[0-9]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\p{Decimal_Number}--[0-9]",
+                    "left": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 20,
+                      "raw": "\\p{Decimal_Number}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "General_Category",
+                      "value": "Decimal_Number",
+                      "negate": false
+                    },
+                    "right": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 22,
+                      "end": 27,
+                      "raw": "[0-9]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "CharacterClassRange",
+                          "parent": "♻️../..",
+                          "start": 23,
+                          "end": 26,
+                          "raw": "0-9",
+                          "min": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 23,
+                            "end": 24,
+                            "raw": "0",
+                            "value": 48
+                          },
+                          "max": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 25,
+                            "end": 26,
+                            "raw": "9",
+                            "value": 57
+                          }
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\p{Script=Khmer}&&[\\p{Letter}\\p{Mark}\\p{Number}]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 53,
+        "raw": "/[\\p{Script=Khmer}&&[\\p{Letter}\\p{Mark}\\p{Number}]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 51,
+          "raw": "[\\p{Script=Khmer}&&[\\p{Letter}\\p{Mark}\\p{Number}]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 51,
+              "raw": "[\\p{Script=Khmer}&&[\\p{Letter}\\p{Mark}\\p{Number}]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 51,
+                  "raw": "[\\p{Script=Khmer}&&[\\p{Letter}\\p{Mark}\\p{Number}]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 50,
+                    "raw": "\\p{Script=Khmer}&&[\\p{Letter}\\p{Mark}\\p{Number}]",
+                    "left": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 18,
+                      "raw": "\\p{Script=Khmer}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "Script",
+                      "value": "Khmer",
+                      "negate": false
+                    },
+                    "right": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 20,
+                      "end": 50,
+                      "raw": "[\\p{Letter}\\p{Mark}\\p{Number}]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 21,
+                          "end": 31,
+                          "raw": "\\p{Letter}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Letter",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 31,
+                          "end": 39,
+                          "raw": "\\p{Mark}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Mark",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 39,
+                          "end": 49,
+                          "raw": "\\p{Number}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Number",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 52,
+          "end": 53,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\p{White_Space}--\\p{Line_Break=Glue}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[\\p{White_Space}--\\p{Line_Break=Glue}]/v: Invalid property name",
+        "index": 37
+      }
+    },
+    "/[\\p{Emoji}--[#*0-9]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/[\\p{Emoji}--[#*0-9]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "[\\p{Emoji}--[#*0-9]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "[\\p{Emoji}--[#*0-9]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 21,
+                  "raw": "[\\p{Emoji}--[#*0-9]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Emoji}--[#*0-9]",
+                    "left": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 11,
+                      "raw": "\\p{Emoji}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "Emoji",
+                      "value": null,
+                      "negate": false
+                    },
+                    "right": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 13,
+                      "end": 20,
+                      "raw": "[#*0-9]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": "#",
+                          "value": 35
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 16,
+                          "raw": "*",
+                          "value": 42
+                        },
+                        {
+                          "type": "CharacterClassRange",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 19,
+                          "raw": "0-9",
+                          "min": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 16,
+                            "end": 17,
+                            "raw": "0",
+                            "value": 48
+                          },
+                          "max": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 18,
+                            "end": 19,
+                            "raw": "9",
+                            "value": 57
+                          }
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\p{Emoji}--\\p{ASCII}]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/[\\p{Emoji}--\\p{ASCII}]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "[\\p{Emoji}--\\p{ASCII}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "[\\p{Emoji}--\\p{ASCII}]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 23,
+                  "raw": "[\\p{Emoji}--\\p{ASCII}]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Emoji}--\\p{ASCII}",
+                    "left": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 11,
+                      "raw": "\\p{Emoji}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "Emoji",
+                      "value": null,
+                      "negate": false
+                    },
+                    "right": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 13,
+                      "end": 22,
+                      "raw": "\\p{ASCII}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "ASCII",
+                      "value": null,
+                      "negate": false
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\p{Nonspacing_Mark}&&[\\p{Script=Inherited}\\p{Script=Common}]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 65,
+        "raw": "/[\\p{Nonspacing_Mark}&&[\\p{Script=Inherited}\\p{Script=Common}]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 63,
+          "raw": "[\\p{Nonspacing_Mark}&&[\\p{Script=Inherited}\\p{Script=Common}]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 63,
+              "raw": "[\\p{Nonspacing_Mark}&&[\\p{Script=Inherited}\\p{Script=Common}]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 63,
+                  "raw": "[\\p{Nonspacing_Mark}&&[\\p{Script=Inherited}\\p{Script=Common}]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 62,
+                    "raw": "\\p{Nonspacing_Mark}&&[\\p{Script=Inherited}\\p{Script=Common}]",
+                    "left": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 21,
+                      "raw": "\\p{Nonspacing_Mark}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "General_Category",
+                      "value": "Nonspacing_Mark",
+                      "negate": false
+                    },
+                    "right": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 23,
+                      "end": 62,
+                      "raw": "[\\p{Script=Inherited}\\p{Script=Common}]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 24,
+                          "end": 44,
+                          "raw": "\\p{Script=Inherited}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "Script",
+                          "value": "Inherited",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 44,
+                          "end": 61,
+                          "raw": "\\p{Script=Common}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "Script",
+                          "value": "Common",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 64,
+          "end": 65,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[[\\p{Other}\\p{Separator}\\p{White_Space}\\p{Default_Ignorable_Code_Point}]--\\x20]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 82,
+        "raw": "/[[\\p{Other}\\p{Separator}\\p{White_Space}\\p{Default_Ignorable_Code_Point}]--\\x20]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 80,
+          "raw": "[[\\p{Other}\\p{Separator}\\p{White_Space}\\p{Default_Ignorable_Code_Point}]--\\x20]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 80,
+              "raw": "[[\\p{Other}\\p{Separator}\\p{White_Space}\\p{Default_Ignorable_Code_Point}]--\\x20]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 80,
+                  "raw": "[[\\p{Other}\\p{Separator}\\p{White_Space}\\p{Default_Ignorable_Code_Point}]--\\x20]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 79,
+                    "raw": "[\\p{Other}\\p{Separator}\\p{White_Space}\\p{Default_Ignorable_Code_Point}]--\\x20",
+                    "left": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 73,
+                      "raw": "[\\p{Other}\\p{Separator}\\p{White_Space}\\p{Default_Ignorable_Code_Point}]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 12,
+                          "raw": "\\p{Other}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Other",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 25,
+                          "raw": "\\p{Separator}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Separator",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 25,
+                          "end": 40,
+                          "raw": "\\p{White_Space}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "White_Space",
+                          "value": null,
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 40,
+                          "end": 72,
+                          "raw": "\\p{Default_Ignorable_Code_Point}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "Default_Ignorable_Code_Point",
+                          "value": null,
+                          "negate": false
+                        }
+                      ]
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 75,
+                      "end": 79,
+                      "raw": "\\x20",
+                      "value": 32
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 81,
+          "end": 82,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\P{NFC_Quick_Check=No}--\\p{Script=Common}--\\p{Script=Inherited}--\\p{Script=Unknown}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[\\P{NFC_Quick_Check=No}--\\p{Script=Common}--\\p{Script=Inherited}--\\p{Script=Unknown}]/v: Invalid property name",
+        "index": 23
+      }
+    },
+    "/[\\p{Script_Extensions=Greek}&&[\\p{Letter}\\p{Mark}\\p{Decimal_Number}]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 72,
+        "raw": "/[\\p{Script_Extensions=Greek}&&[\\p{Letter}\\p{Mark}\\p{Decimal_Number}]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 70,
+          "raw": "[\\p{Script_Extensions=Greek}&&[\\p{Letter}\\p{Mark}\\p{Decimal_Number}]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 70,
+              "raw": "[\\p{Script_Extensions=Greek}&&[\\p{Letter}\\p{Mark}\\p{Decimal_Number}]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 70,
+                  "raw": "[\\p{Script_Extensions=Greek}&&[\\p{Letter}\\p{Mark}\\p{Decimal_Number}]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 69,
+                    "raw": "\\p{Script_Extensions=Greek}&&[\\p{Letter}\\p{Mark}\\p{Decimal_Number}]",
+                    "left": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 29,
+                      "raw": "\\p{Script_Extensions=Greek}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "Script_Extensions",
+                      "value": "Greek",
+                      "negate": false
+                    },
+                    "right": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 31,
+                      "end": 69,
+                      "raw": "[\\p{Letter}\\p{Mark}\\p{Decimal_Number}]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 32,
+                          "end": 42,
+                          "raw": "\\p{Letter}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Letter",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 42,
+                          "end": 50,
+                          "raw": "\\p{Mark}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Mark",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 50,
+                          "end": 68,
+                          "raw": "\\p{Decimal_Number}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Decimal_Number",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 71,
+          "end": 72,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[[\\p{Any}--\\p{Other}]\\p{Control}]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/[[\\p{Any}--\\p{Other}]\\p{Control}]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "[[\\p{Any}--\\p{Other}]\\p{Control}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "[[\\p{Any}--\\p{Other}]\\p{Control}]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 34,
+                  "raw": "[[\\p{Any}--\\p{Other}]\\p{Control}]",
+                  "unicodeSets": true,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 22,
+                      "raw": "[\\p{Any}--\\p{Other}]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassSubtraction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 21,
+                        "raw": "\\p{Any}--\\p{Other}",
+                        "left": {
+                          "type": "CharacterSet",
+                          "parent": "♻️..",
+                          "start": 3,
+                          "end": 10,
+                          "raw": "\\p{Any}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "Any",
+                          "value": null,
+                          "negate": false
+                        },
+                        "right": {
+                          "type": "CharacterSet",
+                          "parent": "♻️..",
+                          "start": 12,
+                          "end": 21,
+                          "raw": "\\p{Other}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Other",
+                          "negate": false
+                        }
+                      }
+                    },
+                    {
+                      "type": "CharacterSet",
+                      "parent": "♻️../..",
+                      "start": 22,
+                      "end": 33,
+                      "raw": "\\p{Control}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "General_Category",
+                      "value": "Control",
+                      "negate": false
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\p{Assigned}--\\p{Separator}]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/[\\p{Assigned}--\\p{Separator}]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "[\\p{Assigned}--\\p{Separator}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "[\\p{Assigned}--\\p{Separator}]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 30,
+                  "raw": "[\\p{Assigned}--\\p{Separator}]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Assigned}--\\p{Separator}",
+                    "left": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 14,
+                      "raw": "\\p{Assigned}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "Assigned",
+                      "value": null,
+                      "negate": false
+                    },
+                    "right": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 16,
+                      "end": 29,
+                      "raw": "\\p{Separator}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "General_Category",
+                      "value": "Separator",
+                      "negate": false
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[[\\p{Bidi_Class=R}\\p{Bidi_Class=AL}]--\\p{Unassigned}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[[\\p{Bidi_Class=R}\\p{Bidi_Class=AL}]--\\p{Unassigned}]/v: Invalid property name",
+        "index": 18
+      }
+    },
+    "/[\\p{Letter}&&[\\p{Bidi_Class=R}\\p{Bidi_Class=AL}]]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[\\p{Letter}&&[\\p{Bidi_Class=R}\\p{Bidi_Class=AL}]]/v: Invalid property name",
+        "index": 30
+      }
+    },
+    "/[\\p{Other}--\\p{Format}--\\p{Control}]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/[\\p{Other}--\\p{Format}--\\p{Control}]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "[\\p{Other}--\\p{Format}--\\p{Control}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "[\\p{Other}--\\p{Format}--\\p{Control}]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 37,
+                  "raw": "[\\p{Other}--\\p{Format}--\\p{Control}]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "\\p{Other}--\\p{Format}--\\p{Control}",
+                    "left": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 23,
+                      "raw": "\\p{Other}--\\p{Format}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 11,
+                        "raw": "\\p{Other}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "General_Category",
+                        "value": "Other",
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 13,
+                        "end": 23,
+                        "raw": "\\p{Format}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "General_Category",
+                        "value": "Format",
+                        "negate": false
+                      }
+                    },
+                    "right": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 25,
+                      "end": 36,
+                      "raw": "\\p{Control}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "General_Category",
+                      "value": "Control",
+                      "negate": false
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\p{RGI_Emoji}--\\q{🇧🇪}]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/[\\p{RGI_Emoji}--\\q{🇧🇪}]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "[\\p{RGI_Emoji}--\\q{🇧🇪}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "[\\p{RGI_Emoji}--\\q{🇧🇪}]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 26,
+                  "raw": "[\\p{RGI_Emoji}--\\q{🇧🇪}]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{RGI_Emoji}--\\q{🇧🇪}",
+                    "left": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 15,
+                      "raw": "\\p{RGI_Emoji}",
+                      "kind": "property",
+                      "strings": true,
+                      "key": "RGI_Emoji",
+                      "value": null,
+                      "negate": false
+                    },
+                    "right": {
+                      "type": "ClassStringDisjunction",
+                      "parent": "♻️..",
+                      "start": 17,
+                      "end": 25,
+                      "raw": "\\q{🇧🇪}",
+                      "alternatives": [
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 24,
+                          "raw": "🇧🇪",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 20,
+                              "end": 22,
+                              "raw": "🇧",
+                              "value": 127463
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 22,
+                              "end": 24,
+                              "raw": "🇪",
+                              "value": 127466
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\p{RGI_Emoji_ZWJ_Sequence}--\\q{🇧🇪}]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/[\\p{RGI_Emoji_ZWJ_Sequence}--\\q{🇧🇪}]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "[\\p{RGI_Emoji_ZWJ_Sequence}--\\q{🇧🇪}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "[\\p{RGI_Emoji_ZWJ_Sequence}--\\q{🇧🇪}]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 39,
+                  "raw": "[\\p{RGI_Emoji_ZWJ_Sequence}--\\q{🇧🇪}]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 38,
+                    "raw": "\\p{RGI_Emoji_ZWJ_Sequence}--\\q{🇧🇪}",
+                    "left": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 28,
+                      "raw": "\\p{RGI_Emoji_ZWJ_Sequence}",
+                      "kind": "property",
+                      "strings": true,
+                      "key": "RGI_Emoji_ZWJ_Sequence",
+                      "value": null,
+                      "negate": false
+                    },
+                    "right": {
+                      "type": "ClassStringDisjunction",
+                      "parent": "♻️..",
+                      "start": 30,
+                      "end": 38,
+                      "raw": "\\q{🇧🇪}",
+                      "alternatives": [
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 33,
+                          "end": 37,
+                          "raw": "🇧🇪",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 33,
+                              "end": 35,
+                              "raw": "🇧",
+                              "value": 127463
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 35,
+                              "end": 37,
+                              "raw": "🇪",
+                              "value": 127466
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[a-c\\q{W|xy|xyz}]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/[a-c\\q{W|xy|xyz}]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "[a-c\\q{W|xy|xyz}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "[a-c\\q{W|xy|xyz}]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 18,
+                  "raw": "[a-c\\q{W|xy|xyz}]",
+                  "unicodeSets": true,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-c",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "c",
+                        "value": 99
+                      }
+                    },
+                    {
+                      "type": "ClassStringDisjunction",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 17,
+                      "raw": "\\q{W|xy|xyz}",
+                      "alternatives": [
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "W",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 9,
+                              "raw": "W",
+                              "value": 87
+                            }
+                          ]
+                        },
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 12,
+                          "raw": "xy",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 10,
+                              "end": 11,
+                              "raw": "x",
+                              "value": 120
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "y",
+                              "value": 121
+                            }
+                          ]
+                        },
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 16,
+                          "raw": "xyz",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 13,
+                              "end": 14,
+                              "raw": "x",
+                              "value": 120
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 14,
+                              "end": 15,
+                              "raw": "y",
+                              "value": 121
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 15,
+                              "end": 16,
+                              "raw": "z",
+                              "value": 122
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/class-set-expression-subtraction-invalid-2024.json b/test/fixtures/parser/literal/class-set-expression-subtraction-invalid-2024.json
new file mode 100644
index 0000000..d002ed3
--- /dev/null
+++ b/test/fixtures/parser/literal/class-set-expression-subtraction-invalid-2024.json
@@ -0,0 +1,20 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/[^[\\q{abc|d|e|f}--\\q{d|e|f}]]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^[\\q{abc|d|e|f}--\\q{d|e|f}]]/v: Negated character class may contain strings",
+        "index": 30
+      }
+    },
+    "/[^[\\q{}--\\q{d|e|f}]]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^[\\q{}--\\q{d|e|f}]]/v: Negated character class may contain strings",
+        "index": 21
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/class-set-expression-subtraction-valid-2024.json b/test/fixtures/parser/literal/class-set-expression-subtraction-valid-2024.json
new file mode 100644
index 0000000..c3754a2
--- /dev/null
+++ b/test/fixtures/parser/literal/class-set-expression-subtraction-valid-2024.json
@@ -0,0 +1,1944 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/[A--B]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[A--B]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "[A--B]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "[A--B]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "[A--B]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 6,
+                    "raw": "A--B",
+                    "left": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "A",
+                      "value": 65
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "B",
+                      "value": 66
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[A--B--C]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/[A--B--C]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "[A--B--C]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "[A--B--C]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "[A--B--C]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "A--B--C",
+                    "left": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "A--B",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "A",
+                        "value": 65
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "B",
+                        "value": 66
+                      }
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "C",
+                      "value": 67
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[^A--B]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[^A--B]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[^A--B]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[^A--B]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[^A--B]",
+                  "negate": true,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "A--B",
+                    "left": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "A",
+                      "value": 65
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "B",
+                      "value": 66
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[A--B]?/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[A--B]?/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[A--B]?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[A--B]?",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[A--B]?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 7,
+                    "raw": "[A--B]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "A--B",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "A",
+                        "value": 65
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "B",
+                        "value": 66
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\w--[0-9]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[\\w--[0-9]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[\\w--[0-9]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[\\w--[0-9]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "[\\w--[0-9]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\w--[0-9]",
+                    "left": {
+                      "type": "CharacterSet",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "\\w",
+                      "kind": "word",
+                      "negate": false
+                    },
+                    "right": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 11,
+                      "raw": "[0-9]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "CharacterClassRange",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 10,
+                          "raw": "0-9",
+                          "min": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 7,
+                            "end": 8,
+                            "raw": "0",
+                            "value": 48
+                          },
+                          "max": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "9",
+                            "value": 57
+                          }
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[[A--B]--C]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[[A--B]--C]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[[A--B]--C]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[[A--B]--C]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "[[A--B]--C]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "[A--B]--C",
+                    "left": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "[A--B]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassSubtraction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 7,
+                        "raw": "A--B",
+                        "left": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "A",
+                          "value": 65
+                        },
+                        "right": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "B",
+                          "value": 66
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 10,
+                      "end": 11,
+                      "raw": "C",
+                      "value": 67
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[[A&&B]--C]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[[A&&B]--C]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[[A&&B]--C]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[[A&&B]--C]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "[[A&&B]--C]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "[A&&B]--C",
+                    "left": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "[A&&B]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassIntersection",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 7,
+                        "raw": "A&&B",
+                        "left": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "A",
+                          "value": 65
+                        },
+                        "right": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "B",
+                          "value": 66
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 10,
+                      "end": 11,
+                      "raw": "C",
+                      "value": 67
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[[A--B]&&C]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[[A--B]&&C]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[[A--B]&&C]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[[A--B]&&C]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "[[A--B]&&C]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "[A--B]&&C",
+                    "left": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "[A--B]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassSubtraction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 7,
+                        "raw": "A--B",
+                        "left": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "A",
+                          "value": 65
+                        },
+                        "right": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "B",
+                          "value": 66
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 10,
+                      "end": 11,
+                      "raw": "C",
+                      "value": 67
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[A--[B--C]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[A--[B--C]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[A--[B--C]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[A--[B--C]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "[A--[B--C]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "A--[B--C]",
+                    "left": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "A",
+                      "value": 65
+                    },
+                    "right": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 11,
+                      "raw": "[B--C]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassSubtraction",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 10,
+                        "raw": "B--C",
+                        "left": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "B",
+                          "value": 66
+                        },
+                        "right": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "C",
+                          "value": 67
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[A--[B&&C]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[A--[B&&C]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[A--[B&&C]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[A--[B&&C]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "[A--[B&&C]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "A--[B&&C]",
+                    "left": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "A",
+                      "value": 65
+                    },
+                    "right": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 11,
+                      "raw": "[B&&C]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassIntersection",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 10,
+                        "raw": "B&&C",
+                        "left": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "B",
+                          "value": 66
+                        },
+                        "right": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "C",
+                          "value": 67
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\q{abc|def|ghi}--\\q{def}]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/[\\q{abc|def|ghi}--\\q{def}]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "[\\q{abc|def|ghi}--\\q{def}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "[\\q{abc|def|ghi}--\\q{def}]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 27,
+                  "raw": "[\\q{abc|def|ghi}--\\q{def}]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\q{abc|def|ghi}--\\q{def}",
+                    "left": {
+                      "type": "ClassStringDisjunction",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 17,
+                      "raw": "\\q{abc|def|ghi}",
+                      "alternatives": [
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 8,
+                          "raw": "abc",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 5,
+                              "end": 6,
+                              "raw": "a",
+                              "value": 97
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "b",
+                              "value": 98
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "c",
+                              "value": 99
+                            }
+                          ]
+                        },
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 12,
+                          "raw": "def",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "d",
+                              "value": 100
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 10,
+                              "end": 11,
+                              "raw": "e",
+                              "value": 101
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "f",
+                              "value": 102
+                            }
+                          ]
+                        },
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 16,
+                          "raw": "ghi",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 13,
+                              "end": 14,
+                              "raw": "g",
+                              "value": 103
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 14,
+                              "end": 15,
+                              "raw": "h",
+                              "value": 104
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 15,
+                              "end": 16,
+                              "raw": "i",
+                              "value": 105
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    "right": {
+                      "type": "ClassStringDisjunction",
+                      "parent": "♻️..",
+                      "start": 19,
+                      "end": 26,
+                      "raw": "\\q{def}",
+                      "alternatives": [
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 25,
+                          "raw": "def",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 22,
+                              "end": 23,
+                              "raw": "d",
+                              "value": 100
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 23,
+                              "end": 24,
+                              "raw": "e",
+                              "value": 101
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 24,
+                              "end": 25,
+                              "raw": "f",
+                              "value": 102
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[^[\\q{a|b|c}--\\q{b}]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/[^[\\q{a|b|c}--\\q{b}]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "[^[\\q{a|b|c}--\\q{b}]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "[^[\\q{a|b|c}--\\q{b}]]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 22,
+                  "raw": "[^[\\q{a|b|c}--\\q{b}]]",
+                  "unicodeSets": true,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 21,
+                      "raw": "[\\q{a|b|c}--\\q{b}]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassSubtraction",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 20,
+                        "raw": "\\q{a|b|c}--\\q{b}",
+                        "left": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 13,
+                          "raw": "\\q{a|b|c}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "a",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "b",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "c",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        "right": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 15,
+                          "end": 20,
+                          "raw": "\\q{b}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 18,
+                              "end": 19,
+                              "raw": "b",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 18,
+                                  "end": 19,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[^[\\q{a|b|c}--\\q{def}]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/[^[\\q{a|b|c}--\\q{def}]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "[^[\\q{a|b|c}--\\q{def}]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "[^[\\q{a|b|c}--\\q{def}]]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 24,
+                  "raw": "[^[\\q{a|b|c}--\\q{def}]]",
+                  "unicodeSets": true,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 23,
+                      "raw": "[\\q{a|b|c}--\\q{def}]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassSubtraction",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 22,
+                        "raw": "\\q{a|b|c}--\\q{def}",
+                        "left": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 13,
+                          "raw": "\\q{a|b|c}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "a",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "b",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "c",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        "right": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 15,
+                          "end": 22,
+                          "raw": "\\q{def}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 18,
+                              "end": 21,
+                              "raw": "def",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 18,
+                                  "end": 19,
+                                  "raw": "d",
+                                  "value": 100
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 19,
+                                  "end": 20,
+                                  "raw": "e",
+                                  "value": 101
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 20,
+                                  "end": 21,
+                                  "raw": "f",
+                                  "value": 102
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[^[\\q{a|b|c}--\\q{}]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/[^[\\q{a|b|c}--\\q{}]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "[^[\\q{a|b|c}--\\q{}]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "[^[\\q{a|b|c}--\\q{}]]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 21,
+                  "raw": "[^[\\q{a|b|c}--\\q{}]]",
+                  "unicodeSets": true,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 20,
+                      "raw": "[\\q{a|b|c}--\\q{}]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassSubtraction",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 19,
+                        "raw": "\\q{a|b|c}--\\q{}",
+                        "left": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 13,
+                          "raw": "\\q{a|b|c}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "a",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "b",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            },
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "c",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        "right": {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️..",
+                          "start": 15,
+                          "end": 19,
+                          "raw": "\\q{}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 18,
+                              "end": 18,
+                              "raw": "",
+                              "elements": []
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[A--&]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[A--&]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "[A--&]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "[A--&]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "[A--&]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 6,
+                    "raw": "A--&",
+                    "left": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "A",
+                      "value": 65
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "&",
+                      "value": 38
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[a--b--[c--d--e]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/[a--b--[c--d--e]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "[a--b--[c--d--e]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "[a--b--[c--d--e]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 18,
+                  "raw": "[a--b--[c--d--e]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "a--b--[c--d--e]",
+                    "left": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "a--b",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "b",
+                        "value": 98
+                      }
+                    },
+                    "right": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 8,
+                      "end": 17,
+                      "raw": "[c--d--e]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassSubtraction",
+                        "parent": "♻️..",
+                        "start": 9,
+                        "end": 16,
+                        "raw": "c--d--e",
+                        "left": {
+                          "type": "ClassSubtraction",
+                          "parent": "♻️..",
+                          "start": 9,
+                          "end": 13,
+                          "raw": "c--d",
+                          "left": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "c",
+                            "value": 99
+                          },
+                          "right": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 12,
+                            "end": 13,
+                            "raw": "d",
+                            "value": 100
+                          }
+                        },
+                        "right": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 15,
+                          "end": 16,
+                          "raw": "e",
+                          "value": 101
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[a--b--[c&&d&&[e--f--g]]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/[a--b--[c&&d&&[e--f--g]]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "[a--b--[c&&d&&[e--f--g]]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "[a--b--[c&&d&&[e--f--g]]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 26,
+                  "raw": "[a--b--[c&&d&&[e--f--g]]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassSubtraction",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "a--b--[c&&d&&[e--f--g]]",
+                    "left": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "a--b",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "b",
+                        "value": 98
+                      }
+                    },
+                    "right": {
+                      "type": "ExpressionCharacterClass",
+                      "parent": "♻️..",
+                      "start": 8,
+                      "end": 25,
+                      "raw": "[c&&d&&[e--f--g]]",
+                      "negate": false,
+                      "expression": {
+                        "type": "ClassIntersection",
+                        "parent": "♻️..",
+                        "start": 9,
+                        "end": 24,
+                        "raw": "c&&d&&[e--f--g]",
+                        "left": {
+                          "type": "ClassIntersection",
+                          "parent": "♻️..",
+                          "start": 9,
+                          "end": 13,
+                          "raw": "c&&d",
+                          "left": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "c",
+                            "value": 99
+                          },
+                          "right": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 12,
+                            "end": 13,
+                            "raw": "d",
+                            "value": 100
+                          }
+                        },
+                        "right": {
+                          "type": "ExpressionCharacterClass",
+                          "parent": "♻️..",
+                          "start": 15,
+                          "end": 24,
+                          "raw": "[e--f--g]",
+                          "negate": false,
+                          "expression": {
+                            "type": "ClassSubtraction",
+                            "parent": "♻️..",
+                            "start": 16,
+                            "end": 23,
+                            "raw": "e--f--g",
+                            "left": {
+                              "type": "ClassSubtraction",
+                              "parent": "♻️..",
+                              "start": 16,
+                              "end": 20,
+                              "raw": "e--f",
+                              "left": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 16,
+                                "end": 17,
+                                "raw": "e",
+                                "value": 101
+                              },
+                              "right": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 19,
+                                "end": 20,
+                                "raw": "f",
+                                "value": 102
+                              }
+                            },
+                            "right": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 22,
+                              "end": 23,
+                              "raw": "g",
+                              "value": 103
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/class-set-expression-valid-2024.json b/test/fixtures/parser/literal/class-set-expression-valid-2024.json
new file mode 100644
index 0000000..1976f1d
--- /dev/null
+++ b/test/fixtures/parser/literal/class-set-expression-valid-2024.json
@@ -0,0 +1,1113 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/[\\p{Basic_Emoji}][^a]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/[\\p{Basic_Emoji}][^a]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "[\\p{Basic_Emoji}][^a]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "[\\p{Basic_Emoji}][^a]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 18,
+                  "raw": "[\\p{Basic_Emoji}]",
+                  "unicodeSets": true,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterSet",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 17,
+                      "raw": "\\p{Basic_Emoji}",
+                      "kind": "property",
+                      "strings": true,
+                      "key": "Basic_Emoji",
+                      "value": null,
+                      "negate": false
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 22,
+                  "raw": "[^a]",
+                  "unicodeSets": true,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 20,
+                      "end": 21,
+                      "raw": "a",
+                      "value": 97
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[A&&[&B]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/[A&&[&B]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "[A&&[&B]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "[A&&[&B]]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "[A&&[&B]]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "A&&[&B]",
+                    "left": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "A",
+                      "value": 65
+                    },
+                    "right": {
+                      "type": "CharacterClass",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "[&B]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "&",
+                          "value": 38
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "B",
+                          "value": 66
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[A&&\\&]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[A&&\\&]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[A&&\\&]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[A&&\\&]",
+              "elements": [
+                {
+                  "type": "ExpressionCharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[A&&\\&]",
+                  "negate": false,
+                  "expression": {
+                    "type": "ClassIntersection",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "A&&\\&",
+                    "left": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "A",
+                      "value": 65
+                    },
+                    "right": {
+                      "type": "Character",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "\\&",
+                      "value": 38
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[a-bc-d]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/[a-bc-d]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[a-bc-d]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[a-bc-d]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[a-bc-d]",
+                  "unicodeSets": true,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-b",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "b",
+                        "value": 98
+                      }
+                    },
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "c-d",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "c",
+                        "value": 99
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 8,
+                        "raw": "d",
+                        "value": 100
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/[]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "[]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "[]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "[]",
+                  "unicodeSets": true,
+                  "negate": false,
+                  "elements": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[^]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/[^]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "[^]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "[^]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "[^]",
+                  "unicodeSets": true,
+                  "negate": true,
+                  "elements": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[^\\q{a}]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/[^\\q{a}]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[^\\q{a}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[^\\q{a}]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[^\\q{a}]",
+                  "unicodeSets": true,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "ClassStringDisjunction",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 8,
+                      "raw": "\\q{a}",
+                      "alternatives": [
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "a",
+                              "value": 97
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[^\\q{a|b}]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/[^\\q{a|b}]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "[^\\q{a|b}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "[^\\q{a|b}]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "[^\\q{a|b}]",
+                  "unicodeSets": true,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "ClassStringDisjunction",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 10,
+                      "raw": "\\q{a|b}",
+                      "alternatives": [
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "a",
+                              "value": 97
+                            }
+                          ]
+                        },
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "b",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 9,
+                              "raw": "b",
+                              "value": 98
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[\\q{0|1\\uFE0F\\u20E3|2|3\\uFE0F\\u20E3}]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/[\\q{0|1\\uFE0F\\u20E3|2|3\\uFE0F\\u20E3}]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "[\\q{0|1\\uFE0F\\u20E3|2|3\\uFE0F\\u20E3}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "[\\q{0|1\\uFE0F\\u20E3|2|3\\uFE0F\\u20E3}]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 38,
+                  "raw": "[\\q{0|1\\uFE0F\\u20E3|2|3\\uFE0F\\u20E3}]",
+                  "unicodeSets": true,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "ClassStringDisjunction",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 37,
+                      "raw": "\\q{0|1\\uFE0F\\u20E3|2|3\\uFE0F\\u20E3}",
+                      "alternatives": [
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "0",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 5,
+                              "end": 6,
+                              "raw": "0",
+                              "value": 48
+                            }
+                          ]
+                        },
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 20,
+                          "raw": "1\\uFE0F\\u20E3",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "1",
+                              "value": 49
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 14,
+                              "raw": "\\uFE0F",
+                              "value": 65039
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 14,
+                              "end": 20,
+                              "raw": "\\u20E3",
+                              "value": 8419
+                            }
+                          ]
+                        },
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 21,
+                          "end": 22,
+                          "raw": "2",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 21,
+                              "end": 22,
+                              "raw": "2",
+                              "value": 50
+                            }
+                          ]
+                        },
+                        {
+                          "type": "StringAlternative",
+                          "parent": "♻️../..",
+                          "start": 23,
+                          "end": 36,
+                          "raw": "3\\uFE0F\\u20E3",
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 23,
+                              "end": 24,
+                              "raw": "3",
+                              "value": 51
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 24,
+                              "end": 30,
+                              "raw": "\\uFE0F",
+                              "value": 65039
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 30,
+                              "end": 36,
+                              "raw": "\\u20E3",
+                              "value": 8419
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[[a][b]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/[[a][b]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[[a][b]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[[a][b]]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[[a][b]]",
+                  "unicodeSets": true,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClass",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "[a]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    },
+                    {
+                      "type": "CharacterClass",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "[b]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[[\\q{ab}][^c]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/[[\\q{ab}][^c]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "[[\\q{ab}][^c]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "[[\\q{ab}][^c]]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "[[\\q{ab}][^c]]",
+                  "unicodeSets": true,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClass",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 10,
+                      "raw": "[\\q{ab}]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 9,
+                          "raw": "\\q{ab}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 8,
+                              "raw": "ab",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 7,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    {
+                      "type": "CharacterClass",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 14,
+                      "raw": "[^c]",
+                      "unicodeSets": true,
+                      "negate": true,
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/[[\\q{ab}][^]]/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/[[\\q{ab}][^]]/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "[[\\q{ab}][^]]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "[[\\q{ab}][^]]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "[[\\q{ab}][^]]",
+                  "unicodeSets": true,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClass",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 10,
+                      "raw": "[\\q{ab}]",
+                      "unicodeSets": true,
+                      "negate": false,
+                      "elements": [
+                        {
+                          "type": "ClassStringDisjunction",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 9,
+                          "raw": "\\q{ab}",
+                          "alternatives": [
+                            {
+                              "type": "StringAlternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 8,
+                              "raw": "ab",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 7,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    {
+                      "type": "CharacterClass",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 13,
+                      "raw": "[^]",
+                      "unicodeSets": true,
+                      "negate": true,
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/duplicate-named-capturing-group-invalid-2024.json b/test/fixtures/parser/literal/duplicate-named-capturing-group-invalid-2024.json
new file mode 100644
index 0000000..e61353f
--- /dev/null
+++ b/test/fixtures/parser/literal/duplicate-named-capturing-group-invalid-2024.json
@@ -0,0 +1,14 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/(?<year>[0-9]{4})-[0-9]{2}|[0-9]{2}-(?<year>[0-9]{4})/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<year>[0-9]{4})-[0-9]{2}|[0-9]{2}-(?<year>[0-9]{4})/: Duplicate capture group name",
+        "index": 45
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/duplicate-named-capturing-group-invalid-2025.json b/test/fixtures/parser/literal/duplicate-named-capturing-group-invalid-2025.json
new file mode 100644
index 0000000..40c68ad
--- /dev/null
+++ b/test/fixtures/parser/literal/duplicate-named-capturing-group-invalid-2025.json
@@ -0,0 +1,44 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2025
+  },
+  "patterns": {
+    "/(?<year>[0-9]{4})-(?<year>[0-9]{2})/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<year>[0-9]{4})-(?<year>[0-9]{2})/: Duplicate capture group name",
+        "index": 27
+      }
+    },
+    "/(?<x>a)|(?<x>b)(?<x>c)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<x>a)|(?<x>b)(?<x>c)/: Duplicate capture group name",
+        "index": 21
+      }
+    },
+    "/(?:(?<x>a)|(?<x>b))(?<x>c)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?:(?<x>a)|(?<x>b))(?<x>c)/: Duplicate capture group name",
+        "index": 25
+      }
+    },
+    "/(?<x>a)(?:(?<x>b)|(?<x>c))/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<x>a)(?:(?<x>b)|(?<x>c))/: Duplicate capture group name",
+        "index": 16
+      }
+    },
+    "/(?:(?:(?<x>a)|(?<x>b)))(?<x>c)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?:(?:(?<x>a)|(?<x>b)))(?<x>c)/: Duplicate capture group name",
+        "index": 29
+      }
+    },
+    "/(?:(?:(?<x>a)|(?<x>b))|(?:))(?<x>c)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?:(?:(?<x>a)|(?<x>b))|(?:))(?<x>c)/: Duplicate capture group name",
+        "index": 34
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/duplicate-named-capturing-group-valid-2025.json b/test/fixtures/parser/literal/duplicate-named-capturing-group-valid-2025.json
new file mode 100644
index 0000000..56ada83
--- /dev/null
+++ b/test/fixtures/parser/literal/duplicate-named-capturing-group-valid-2025.json
@@ -0,0 +1,729 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2025
+  },
+  "patterns": {
+    "/(?<year>[0-9]{4})-[0-9]{2}|[0-9]{2}-(?<year>[0-9]{4})/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 55,
+        "raw": "/(?<year>[0-9]{4})-[0-9]{2}|[0-9]{2}-(?<year>[0-9]{4})/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 54,
+          "raw": "(?<year>[0-9]{4})-[0-9]{2}|[0-9]{2}-(?<year>[0-9]{4})",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "(?<year>[0-9]{4})-[0-9]{2}",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 18,
+                  "raw": "(?<year>[0-9]{4})",
+                  "name": "year",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 17,
+                      "raw": "[0-9]{4}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 17,
+                          "raw": "[0-9]{4}",
+                          "min": 4,
+                          "max": 4,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 14,
+                            "raw": "[0-9]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterClassRange",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 13,
+                                "raw": "0-9",
+                                "min": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 10,
+                                  "end": 11,
+                                  "raw": "0",
+                                  "value": 48
+                                },
+                                "max": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": "9",
+                                  "value": 57
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "-",
+                  "value": 45
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 27,
+                  "raw": "[0-9]{2}",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 19,
+                    "end": 24,
+                    "raw": "[0-9]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 20,
+                        "end": 23,
+                        "raw": "0-9",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 20,
+                          "end": 21,
+                          "raw": "0",
+                          "value": 48
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 22,
+                          "end": 23,
+                          "raw": "9",
+                          "value": 57
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 28,
+              "end": 54,
+              "raw": "[0-9]{2}-(?<year>[0-9]{4})",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 36,
+                  "raw": "[0-9]{2}",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 28,
+                    "end": 33,
+                    "raw": "[0-9]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 29,
+                        "end": 32,
+                        "raw": "0-9",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 29,
+                          "end": 30,
+                          "raw": "0",
+                          "value": 48
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 31,
+                          "end": 32,
+                          "raw": "9",
+                          "value": 57
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "-",
+                  "value": 45
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 54,
+                  "raw": "(?<year>[0-9]{4})",
+                  "name": "year",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 45,
+                      "end": 53,
+                      "raw": "[0-9]{4}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 45,
+                          "end": 53,
+                          "raw": "[0-9]{4}",
+                          "min": 4,
+                          "max": 4,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 45,
+                            "end": 50,
+                            "raw": "[0-9]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterClassRange",
+                                "parent": "♻️../..",
+                                "start": 46,
+                                "end": 49,
+                                "raw": "0-9",
+                                "min": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 46,
+                                  "end": 47,
+                                  "raw": "0",
+                                  "value": 48
+                                },
+                                "max": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 48,
+                                  "end": 49,
+                                  "raw": "9",
+                                  "value": 57
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 55,
+          "end": 55,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?:(?:(?<x>a)\\k<x>|(?<x>b)\\k<x>)|(?:))\\k<x>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 45,
+        "raw": "/(?:(?:(?<x>a)\\k<x>|(?<x>b)\\k<x>)|(?:))\\k<x>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 44,
+          "raw": "(?:(?:(?<x>a)\\k<x>|(?<x>b)\\k<x>)|(?:))\\k<x>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 44,
+              "raw": "(?:(?:(?<x>a)\\k<x>|(?<x>b)\\k<x>)|(?:))\\k<x>",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 39,
+                  "raw": "(?:(?:(?<x>a)\\k<x>|(?<x>b)\\k<x>)|(?:))",
+                  "modifiers": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 33,
+                      "raw": "(?:(?<x>a)\\k<x>|(?<x>b)\\k<x>)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 33,
+                          "raw": "(?:(?<x>a)\\k<x>|(?<x>b)\\k<x>)",
+                          "modifiers": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 19,
+                              "raw": "(?<x>a)\\k<x>",
+                              "elements": [
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 14,
+                                  "raw": "(?<x>a)",
+                                  "name": "x",
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 12,
+                                      "end": 13,
+                                      "raw": "a",
+                                      "elements": [
+                                        {
+                                          "type": "Character",
+                                          "parent": "♻️../..",
+                                          "start": 12,
+                                          "end": 13,
+                                          "raw": "a",
+                                          "value": 97
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": [
+                                    "♻️../1",
+                                    "♻️../../../1/elements/1",
+                                    "♻️../../../../../../../../../1"
+                                  ]
+                                },
+                                {
+                                  "type": "Backreference",
+                                  "parent": "♻️../..",
+                                  "start": 14,
+                                  "end": 19,
+                                  "raw": "\\k<x>",
+                                  "ref": "x",
+                                  "ambiguous": true,
+                                  "resolved": [
+                                    "♻️../0",
+                                    "♻️../../../1/elements/0"
+                                  ]
+                                }
+                              ]
+                            },
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 20,
+                              "end": 32,
+                              "raw": "(?<x>b)\\k<x>",
+                              "elements": [
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 20,
+                                  "end": 27,
+                                  "raw": "(?<x>b)",
+                                  "name": "x",
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 25,
+                                      "end": 26,
+                                      "raw": "b",
+                                      "elements": [
+                                        {
+                                          "type": "Character",
+                                          "parent": "♻️../..",
+                                          "start": 25,
+                                          "end": 26,
+                                          "raw": "b",
+                                          "value": 98
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": [
+                                    "♻️../../../0/elements/1",
+                                    "♻️../1",
+                                    "♻️../../../../../../../../../1"
+                                  ]
+                                },
+                                {
+                                  "type": "Backreference",
+                                  "parent": "♻️../..",
+                                  "start": 27,
+                                  "end": 32,
+                                  "raw": "\\k<x>",
+                                  "ref": "x",
+                                  "ambiguous": true,
+                                  "resolved": [
+                                    "♻️../../../0/elements/0",
+                                    "♻️../0"
+                                  ]
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 34,
+                      "end": 38,
+                      "raw": "(?:)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 34,
+                          "end": 38,
+                          "raw": "(?:)",
+                          "modifiers": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 37,
+                              "end": 37,
+                              "raw": "",
+                              "elements": []
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 39,
+                  "end": 44,
+                  "raw": "\\k<x>",
+                  "ref": "x",
+                  "ambiguous": true,
+                  "resolved": [
+                    "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0",
+                    "♻️../0/alternatives/0/elements/0/alternatives/1/elements/0"
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 45,
+          "end": 45,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?:(?:(?<x>a\\k<x>)|(?<x>b\\k<x>))|(?:))\\k<x>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 45,
+        "raw": "/(?:(?:(?<x>a\\k<x>)|(?<x>b\\k<x>))|(?:))\\k<x>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 44,
+          "raw": "(?:(?:(?<x>a\\k<x>)|(?<x>b\\k<x>))|(?:))\\k<x>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 44,
+              "raw": "(?:(?:(?<x>a\\k<x>)|(?<x>b\\k<x>))|(?:))\\k<x>",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 39,
+                  "raw": "(?:(?:(?<x>a\\k<x>)|(?<x>b\\k<x>))|(?:))",
+                  "modifiers": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 33,
+                      "raw": "(?:(?<x>a\\k<x>)|(?<x>b\\k<x>))",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 33,
+                          "raw": "(?:(?<x>a\\k<x>)|(?<x>b\\k<x>))",
+                          "modifiers": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 19,
+                              "raw": "(?<x>a\\k<x>)",
+                              "elements": [
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 19,
+                                  "raw": "(?<x>a\\k<x>)",
+                                  "name": "x",
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 12,
+                                      "end": 18,
+                                      "raw": "a\\k<x>",
+                                      "elements": [
+                                        {
+                                          "type": "Character",
+                                          "parent": "♻️../..",
+                                          "start": 12,
+                                          "end": 13,
+                                          "raw": "a",
+                                          "value": 97
+                                        },
+                                        {
+                                          "type": "Backreference",
+                                          "parent": "♻️../..",
+                                          "start": 13,
+                                          "end": 18,
+                                          "raw": "\\k<x>",
+                                          "ref": "x",
+                                          "ambiguous": true,
+                                          "resolved": [
+                                            "♻️../../../..",
+                                            "♻️../../../../../../../1/elements/0"
+                                          ]
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": [
+                                    "♻️alternatives/0/elements/1",
+                                    "♻️../../../1/elements/0/alternatives/0/elements/1",
+                                    "♻️../../../../../../../../../1"
+                                  ]
+                                }
+                              ]
+                            },
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 20,
+                              "end": 32,
+                              "raw": "(?<x>b\\k<x>)",
+                              "elements": [
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 20,
+                                  "end": 32,
+                                  "raw": "(?<x>b\\k<x>)",
+                                  "name": "x",
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 25,
+                                      "end": 31,
+                                      "raw": "b\\k<x>",
+                                      "elements": [
+                                        {
+                                          "type": "Character",
+                                          "parent": "♻️../..",
+                                          "start": 25,
+                                          "end": 26,
+                                          "raw": "b",
+                                          "value": 98
+                                        },
+                                        {
+                                          "type": "Backreference",
+                                          "parent": "♻️../..",
+                                          "start": 26,
+                                          "end": 31,
+                                          "raw": "\\k<x>",
+                                          "ref": "x",
+                                          "ambiguous": true,
+                                          "resolved": [
+                                            "♻️../../../../../../../0/elements/0",
+                                            "♻️../../../.."
+                                          ]
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": [
+                                    "♻️../../../0/elements/0/alternatives/0/elements/1",
+                                    "♻️alternatives/0/elements/1",
+                                    "♻️../../../../../../../../../1"
+                                  ]
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 34,
+                      "end": 38,
+                      "raw": "(?:)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 34,
+                          "end": 38,
+                          "raw": "(?:)",
+                          "modifiers": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 37,
+                              "end": 37,
+                              "raw": "",
+                              "elements": []
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 39,
+                  "end": 44,
+                  "raw": "\\k<x>",
+                  "ref": "x",
+                  "ambiguous": true,
+                  "resolved": [
+                    "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0",
+                    "♻️../0/alternatives/0/elements/0/alternatives/1/elements/0"
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 45,
+          "end": 45,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/flags-2015.json b/test/fixtures/parser/literal/flags-2015.json
index 82cf234..699acad 100644
--- a/test/fixtures/parser/literal/flags-2015.json
+++ b/test/fixtures/parser/literal/flags-2015.json
@@ -49,7 +49,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -98,7 +99,8 @@
           "unicode": false,
           "sticky": true,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
diff --git a/test/fixtures/parser/literal/flags-2018.json b/test/fixtures/parser/literal/flags-2018.json
index 94de222..91b0e30 100644
--- a/test/fixtures/parser/literal/flags-2018.json
+++ b/test/fixtures/parser/literal/flags-2018.json
@@ -49,7 +49,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": true,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
diff --git a/test/fixtures/parser/literal/flags-2021.json b/test/fixtures/parser/literal/flags-2022.json
similarity index 95%
rename from test/fixtures/parser/literal/flags-2021.json
rename to test/fixtures/parser/literal/flags-2022.json
index 99e6ca1..c19531f 100644
--- a/test/fixtures/parser/literal/flags-2021.json
+++ b/test/fixtures/parser/literal/flags-2022.json
@@ -49,7 +49,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": true
+          "hasIndices": true,
+          "unicodeSets": false
         }
       }
     }
diff --git a/test/fixtures/parser/literal/flags-2024.json b/test/fixtures/parser/literal/flags-2024.json
new file mode 100644
index 0000000..0bf8782
--- /dev/null
+++ b/test/fixtures/parser/literal/flags-2024.json
@@ -0,0 +1,58 @@
+{
+  "options": {
+    "strict": true,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/./v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/./v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/flags-invalid-2017.json b/test/fixtures/parser/literal/flags-invalid-2017.json
new file mode 100644
index 0000000..2dc3b9c
--- /dev/null
+++ b/test/fixtures/parser/literal/flags-invalid-2017.json
@@ -0,0 +1,14 @@
+{
+  "options": {
+    "strict": true,
+    "ecmaVersion": 2017
+  },
+  "patterns": {
+    "/./s": {
+      "error": {
+        "message": "Invalid regular expression: /./s: Invalid flag 's'",
+        "index": 3
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/flags-invalid-2021.json b/test/fixtures/parser/literal/flags-invalid-2021.json
new file mode 100644
index 0000000..1b45ea2
--- /dev/null
+++ b/test/fixtures/parser/literal/flags-invalid-2021.json
@@ -0,0 +1,14 @@
+{
+  "options": {
+    "strict": true,
+    "ecmaVersion": 2021
+  },
+  "patterns": {
+    "/./d": {
+      "error": {
+        "message": "Invalid regular expression: /./d: Invalid flag 'd'",
+        "index": 3
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/flags-invalid-2023.json b/test/fixtures/parser/literal/flags-invalid-2023.json
new file mode 100644
index 0000000..d15f2ce
--- /dev/null
+++ b/test/fixtures/parser/literal/flags-invalid-2023.json
@@ -0,0 +1,14 @@
+{
+  "options": {
+    "strict": true,
+    "ecmaVersion": 2023
+  },
+  "patterns": {
+    "/./v": {
+      "error": {
+        "message": "Invalid regular expression: /./v: Invalid flag 'v'",
+        "index": 3
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/flags-invalid-2024.json b/test/fixtures/parser/literal/flags-invalid-2024.json
new file mode 100644
index 0000000..31297d7
--- /dev/null
+++ b/test/fixtures/parser/literal/flags-invalid-2024.json
@@ -0,0 +1,14 @@
+{
+  "options": {
+    "strict": true,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/./uv": {
+      "error": {
+        "message": "Invalid regular expression: /./uv: Invalid regular expression flags",
+        "index": 3
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/flags-invalid-5.json b/test/fixtures/parser/literal/flags-invalid-5.json
new file mode 100644
index 0000000..72cec20
--- /dev/null
+++ b/test/fixtures/parser/literal/flags-invalid-5.json
@@ -0,0 +1,20 @@
+{
+  "options": {
+    "strict": true,
+    "ecmaVersion": 5
+  },
+  "patterns": {
+    "/./u": {
+      "error": {
+        "message": "Invalid regular expression: /./u: Invalid flag 'u'",
+        "index": 3
+      }
+    },
+    "/./y": {
+      "error": {
+        "message": "Invalid regular expression: /./y: Invalid flag 'y'",
+        "index": 3
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/flags.json b/test/fixtures/parser/literal/flags.json
index 8e2a7bc..52c2834 100644
--- a/test/fixtures/parser/literal/flags.json
+++ b/test/fixtures/parser/literal/flags.json
@@ -31,6 +31,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "(?:)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -58,7 +59,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -89,6 +91,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "(?:)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -116,7 +119,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -147,6 +151,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "(?:)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -174,7 +179,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -205,6 +211,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "(?:)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -232,7 +239,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -263,6 +271,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "(?:)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -290,7 +299,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -321,6 +331,7 @@
                   "start": 1,
                   "end": 5,
                   "raw": "(?:)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -348,7 +359,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
diff --git a/test/fixtures/parser/literal/lookbehind-assertion-valid-2018.json b/test/fixtures/parser/literal/lookbehind-assertion-valid-2018.json
index cf6c889..577502d 100644
--- a/test/fixtures/parser/literal/lookbehind-assertion-valid-2018.json
+++ b/test/fixtures/parser/literal/lookbehind-assertion-valid-2018.json
@@ -69,7 +69,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -138,7 +139,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -207,7 +209,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -276,7 +279,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -384,7 +388,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -492,7 +497,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -600,7 +606,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -708,7 +715,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -833,7 +841,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -958,7 +967,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1066,7 +1076,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1174,7 +1185,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1282,7 +1294,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1390,7 +1403,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1515,7 +1529,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1641,7 +1656,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     }
diff --git a/test/fixtures/parser/literal/modifiers-invalid-2024.json b/test/fixtures/parser/literal/modifiers-invalid-2024.json
new file mode 100644
index 0000000..762b609
--- /dev/null
+++ b/test/fixtures/parser/literal/modifiers-invalid-2024.json
@@ -0,0 +1,26 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/(?ims-ims:sub_expression)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?ims-ims:sub_expression)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?ims:sub_expression)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?ims:sub_expression)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-ims:sub_expression)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-ims:sub_expression)/: Invalid group",
+        "index": 2
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/modifiers-invalid-2025.json b/test/fixtures/parser/literal/modifiers-invalid-2025.json
new file mode 100644
index 0000000..946ef80
--- /dev/null
+++ b/test/fixtures/parser/literal/modifiers-invalid-2025.json
@@ -0,0 +1,56 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2025
+  },
+  "patterns": {
+    "/(?-:sub_expression)?/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-:sub_expression)?/: Invalid empty flags",
+        "index": 4
+      }
+    },
+    "/(?unknown:sub_expression)?/": {
+      "error": {
+        "message": "Invalid regular expression: /(?unknown:sub_expression)?/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?i-unknown:sub_expression)?/": {
+      "error": {
+        "message": "Invalid regular expression: /(?i-unknown:sub_expression)?/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?ii:sub_expression)?/": {
+      "error": {
+        "message": "Invalid regular expression: /(?ii:sub_expression)?/: Duplicated flag 'i'",
+        "index": 3
+      }
+    },
+    "/(?-ii:sub_expression)?/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-ii:sub_expression)?/: Duplicated flag 'i'",
+        "index": 4
+      }
+    },
+    "/(?i-i:sub_expression)?/": {
+      "error": {
+        "message": "Invalid regular expression: /(?i-i:sub_expression)?/: Duplicated flag 'i'",
+        "index": 6
+      }
+    },
+    "/(?iu:sub_expression)?/": {
+      "error": {
+        "message": "Invalid regular expression: /(?iu:sub_expression)?/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-iu:sub_expression)?/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-iu:sub_expression)?/: Invalid group",
+        "index": 2
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/modifiers-valid-2025.json b/test/fixtures/parser/literal/modifiers-valid-2025.json
new file mode 100644
index 0000000..ef709c0
--- /dev/null
+++ b/test/fixtures/parser/literal/modifiers-valid-2025.json
@@ -0,0 +1,461 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2025
+  },
+  "patterns": {
+    "/(?i-m:p)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?i-m:p)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?i-m:p)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?i-m:p)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?i-m:p)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "i-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "p",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "p",
+                          "value": 112
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?ims:p)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?ims:p)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?ims:p)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?ims:p)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?ims:p)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "ims",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "ims",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "p",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "p",
+                          "value": 112
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-ims:p)?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?-ims:p)?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?-ims:p)?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?-ims:p)?",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?-ims:p)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Group",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 10,
+                    "raw": "(?-ims:p)",
+                    "modifiers": {
+                      "type": "Modifiers",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 7,
+                      "raw": "-ims",
+                      "add": {
+                        "type": "ModifierFlags",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 3,
+                        "raw": "",
+                        "ignoreCase": false,
+                        "multiline": false,
+                        "dotAll": false
+                      },
+                      "remove": {
+                        "type": "ModifierFlags",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 7,
+                        "raw": "ims",
+                        "ignoreCase": true,
+                        "multiline": true,
+                        "dotAll": true
+                      }
+                    },
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 8,
+                        "end": 9,
+                        "raw": "p",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "p",
+                            "value": 112
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?:no-modifiers)?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?:no-modifiers)?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "(?:no-modifiers)?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?:no-modifiers)?",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 18,
+                  "raw": "(?:no-modifiers)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Group",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 17,
+                    "raw": "(?:no-modifiers)",
+                    "modifiers": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 16,
+                        "raw": "no-modifiers",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 5,
+                            "raw": "n",
+                            "value": 110
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "o",
+                            "value": 111
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "-",
+                            "value": 45
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 7,
+                            "end": 8,
+                            "raw": "m",
+                            "value": 109
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "o",
+                            "value": 111
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "d",
+                            "value": 100
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "i",
+                            "value": 105
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 11,
+                            "end": 12,
+                            "raw": "f",
+                            "value": 102
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 13,
+                            "raw": "i",
+                            "value": 105
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 13,
+                            "end": 14,
+                            "raw": "e",
+                            "value": 101
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 14,
+                            "end": 15,
+                            "raw": "r",
+                            "value": 114
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 15,
+                            "end": 16,
+                            "raw": "s",
+                            "value": 115
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 19,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/named-backreferences-invalid-2022.json b/test/fixtures/parser/literal/named-backreferences-invalid-2022.json
new file mode 100644
index 0000000..6e83760
--- /dev/null
+++ b/test/fixtures/parser/literal/named-backreferences-invalid-2022.json
@@ -0,0 +1,14 @@
+{
+  "options": {
+    "strict": true,
+    "ecmaVersion": 2022
+  },
+  "patterns": {
+    "/(?<foo>A)\\k<foo>/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<foo>A)\\k<foo>/: Invalid escape",
+        "index": 11
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/named-backreferences-valid-2023.json b/test/fixtures/parser/literal/named-backreferences-valid-2023.json
new file mode 100644
index 0000000..051c04b
--- /dev/null
+++ b/test/fixtures/parser/literal/named-backreferences-valid-2023.json
@@ -0,0 +1,172 @@
+{
+  "options": {
+    "strict": true,
+    "ecmaVersion": 2023
+  },
+  "patterns": {
+    "/(?<foo>A)\\k<foo>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?<foo>A)\\k<foo>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "(?<foo>A)\\k<foo>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "(?<foo>A)\\k<foo>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<foo>A)",
+                  "name": "foo",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "A",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "A",
+                          "value": 65
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 17,
+                  "raw": "\\k<foo>",
+                  "ref": "foo",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 18,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<foo>A)\\k<foo>/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?<foo>A)\\k<foo>/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "(?<foo>A)\\k<foo>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "(?<foo>A)\\k<foo>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<foo>A)",
+                  "name": "foo",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "A",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "A",
+                          "value": 65
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 17,
+                  "raw": "\\k<foo>",
+                  "ref": "foo",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/named-capturing-group-invalid-2018.json b/test/fixtures/parser/literal/named-capturing-group-invalid-2018.json
index ed4d33d..f4ad8a7 100644
--- a/test/fixtures/parser/literal/named-capturing-group-invalid-2018.json
+++ b/test/fixtures/parser/literal/named-capturing-group-invalid-2018.json
@@ -7,13 +7,13 @@
     "/(?a/": {
       "error": {
         "message": "Invalid regular expression: /(?a/: Invalid group",
-        "index": 3
+        "index": 2
       }
     },
     "/(?a)/": {
       "error": {
         "message": "Invalid regular expression: /(?a)/: Invalid group",
-        "index": 3
+        "index": 2
       }
     },
     "/(?</": {
diff --git a/test/fixtures/parser/literal/named-capturing-group-valid-2017.json b/test/fixtures/parser/literal/named-capturing-group-valid-2017.json
index 567e2d4..c3d0a7f 100644
--- a/test/fixtures/parser/literal/named-capturing-group-valid-2017.json
+++ b/test/fixtures/parser/literal/named-capturing-group-valid-2017.json
@@ -49,7 +49,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -122,7 +123,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     }
diff --git a/test/fixtures/parser/literal/named-capturing-group-valid-2018.json b/test/fixtures/parser/literal/named-capturing-group-valid-2018.json
index 9678959..12b1e31 100644
--- a/test/fixtures/parser/literal/named-capturing-group-valid-2018.json
+++ b/test/fixtures/parser/literal/named-capturing-group-valid-2018.json
@@ -69,7 +69,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -100,6 +101,7 @@
                   "start": 1,
                   "end": 6,
                   "raw": "(?:a)",
+                  "modifiers": null,
                   "alternatives": [
                     {
                       "type": "Alternative",
@@ -136,7 +138,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -196,7 +199,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -245,7 +249,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -318,7 +323,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -380,6 +386,7 @@
                   "end": 13,
                   "raw": "\\k<a>",
                   "ref": "a",
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -398,7 +405,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -460,6 +468,7 @@
                   "end": 13,
                   "raw": "\\k<a>",
                   "ref": "a",
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -478,7 +487,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -540,6 +550,7 @@
                   "end": 10,
                   "raw": "\\1",
                   "ref": 1,
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -558,7 +569,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -620,6 +632,7 @@
                   "end": 10,
                   "raw": "\\1",
                   "ref": 1,
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -638,7 +651,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -715,7 +729,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -812,7 +827,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -909,7 +925,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -941,6 +958,7 @@
                   "end": 6,
                   "raw": "\\k<a>",
                   "ref": "a",
+                  "ambiguous": false,
                   "resolved": "♻️../1"
                 },
                 {
@@ -989,7 +1007,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1021,6 +1040,7 @@
                   "end": 6,
                   "raw": "\\k<a>",
                   "ref": "a",
+                  "ambiguous": false,
                   "resolved": "♻️../1"
                 },
                 {
@@ -1069,7 +1089,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1101,6 +1122,7 @@
                   "end": 3,
                   "raw": "\\1",
                   "ref": 1,
+                  "ambiguous": false,
                   "resolved": "♻️../1"
                 },
                 {
@@ -1149,7 +1171,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1181,6 +1204,7 @@
                   "end": 3,
                   "raw": "\\1",
                   "ref": 1,
+                  "ambiguous": false,
                   "resolved": "♻️../1"
                 },
                 {
@@ -1229,7 +1253,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1291,6 +1316,7 @@
                   "end": 19,
                   "raw": "\\k<$abc>",
                   "ref": "$abc",
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -1309,7 +1335,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1371,6 +1398,7 @@
                   "end": 13,
                   "raw": "\\k<あ>",
                   "ref": "あ",
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -1389,7 +1417,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1451,6 +1480,7 @@
                   "end": 22,
                   "raw": "\\k<\\u{20bb7}>",
                   "ref": "𠮷",
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -1469,7 +1499,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1531,6 +1562,7 @@
                   "end": 32,
                   "raw": "\\k<\\u{20bb7}>",
                   "ref": "𠮷",
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -1549,7 +1581,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1611,6 +1644,7 @@
                   "end": 32,
                   "raw": "\\k<\\uD842\\uDFB7>",
                   "ref": "𠮷",
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -1629,7 +1663,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1691,6 +1726,7 @@
                   "end": 32,
                   "raw": "\\k<\\u0061\\u0062\\u0063>",
                   "ref": "abc",
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -1709,7 +1745,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1771,6 +1808,7 @@
                   "end": 32,
                   "raw": "\\k<abc>",
                   "ref": "abc",
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -1789,7 +1827,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1851,6 +1890,7 @@
                   "end": 47,
                   "raw": "\\k<\\u{61}\\u{62}\\u{63}>",
                   "ref": "abc",
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -1869,7 +1909,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -1931,6 +1972,7 @@
                   "end": 15,
                   "raw": "\\k<a1>",
                   "ref": "a1",
+                  "ambiguous": false,
                   "resolved": "♻️../0"
                 }
               ]
@@ -1949,7 +1991,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     }
diff --git a/test/fixtures/parser/literal/test262/LICENSE b/test/fixtures/parser/literal/test262/LICENSE
new file mode 100644
index 0000000..a56b038
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/LICENSE
@@ -0,0 +1,28 @@
+Test262: ECMAScript Test Suite ("Software") is protected by copyright and is being 
+made available under the  "BSD License", included below. This Software may be subject to third party rights (rights 
+from parties other than Ecma International), including patent rights, and no licenses under such third party rights 
+are granted under this license even if the third party concerned is a member of Ecma International.  SEE THE ECMA 
+CODE OF CONDUCT IN PATENT MATTERS AVAILABLE AT https://www.ecma-international.org/ipr FOR 
+INFORMATION REGARDING THE LICENSING OF PATENT CLAIMS THAT ARE REQUIRED TO IMPLEMENT ECMA INTERNATIONAL STANDARDS*.
+
+Copyright (C) 2012 Ecma International
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the 
+following conditions are met:
+1.   Redistributions of source code must retain the above copyright notice, this list of conditions and the following 
+     disclaimer.
+2.   Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the 
+     following disclaimer in the documentation and/or other materials provided with the distribution.
+3.   Neither the name of the authors nor Ecma International may be used to endorse or promote products derived from 
+     this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE ECMA INTERNATIONAL "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
+SHALL ECMA INTERNATIONAL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 
+DAMAGE.
+
+* Ecma International Standards hereafter means Ecma International Standards as well as Ecma Technical Reports
diff --git a/test/fixtures/parser/literal/test262/String.fromCodePoint.json b/test/fixtures/parser/literal/test262/String.fromCodePoint.json
new file mode 100644
index 0000000..67e8729
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/String.fromCodePoint.json
@@ -0,0 +1,1375 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-digit-class-escape-flags-u.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-digit-class-escape-plus-quantifier-flags-u.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-digit-class-escape-plus-quantifier.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-digit-class-escape.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-non-digit-class-escape-flags-u.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-non-digit-class-escape-plus-quantifier-flags-u.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-non-digit-class-escape-plus-quantifier.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-non-digit-class-escape.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-non-whitespace-class-escape-flags-u.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-non-whitespace-class-escape-plus-quantifier-flags-u.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-non-whitespace-class-escape-plus-quantifier.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-non-whitespace-class-escape.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-non-word-class-escape-flags-u.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-non-word-class-escape-plus-quantifier-flags-u.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-non-word-class-escape-plus-quantifier.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-non-word-class-escape.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-whitespace-class-escape-flags-u.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-whitespace-class-escape-plus-quantifier-flags-u.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-whitespace-class-escape-plus-quantifier.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-whitespace-class-escape.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-word-class-escape-flags-u.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-word-class-escape-plus-quantifier-flags-u.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-word-class-escape-plus-quantifier.js",
+    "test/built-ins/RegExp/CharacterClassEscapes/character-class-word-class-escape.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/\\D+/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\D+/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\D+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\D+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\D+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\D",
+                    "kind": "digit",
+                    "negate": true
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\D+/ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/\\D+/ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\D+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\D+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\D+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\D",
+                    "kind": "digit",
+                    "negate": true
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 7,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\D/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\D/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\D",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\D",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\D",
+                  "kind": "digit",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\D/ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\D/ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\D",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\D",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\D",
+                  "kind": "digit",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 6,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\S+/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\S+/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\S+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\S+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\S+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\S",
+                    "kind": "space",
+                    "negate": true
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\S+/ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/\\S+/ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\S+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\S+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\S+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\S",
+                    "kind": "space",
+                    "negate": true
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 7,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\S/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\S/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\S",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\S",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\S",
+                  "kind": "space",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\S/ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\S/ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\S",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\S",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\S",
+                  "kind": "space",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 6,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\W+/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\W+/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\W+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\W+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\W+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\W",
+                    "kind": "word",
+                    "negate": true
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\W+/ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/\\W+/ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\W+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\W+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\W+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\W",
+                    "kind": "word",
+                    "negate": true
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 7,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\W/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\W/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\W",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\W",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\W",
+                  "kind": "word",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\W/ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\W/ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\W",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\W",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\W",
+                  "kind": "word",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 6,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\d+/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\d+/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\d+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\d+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\d+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\d",
+                    "kind": "digit",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\d+/ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/\\d+/ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\d+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\d+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\d+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\d",
+                    "kind": "digit",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 7,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\d/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\d/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\d",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\d",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\d",
+                  "kind": "digit",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\d/ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\d/ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\d",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\d",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\d",
+                  "kind": "digit",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 6,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\s+/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\s+/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\s+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\s+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\s+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\s",
+                    "kind": "space",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\s+/ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/\\s+/ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\s+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\s+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\s+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\s",
+                    "kind": "space",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 7,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\s/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\s/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\s",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\s",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\s",
+                  "kind": "space",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\s/ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\s/ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\s",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\s",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\s",
+                  "kind": "space",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 6,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\w+/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\w+/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\w+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\w+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\w+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\w",
+                    "kind": "word",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\w+/ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/\\w+/ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\w+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\w+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\w+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\w",
+                    "kind": "word",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 7,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\w/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\w/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\w",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\w/ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\w/ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\w",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 6,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/String.prototype.replaceAll-and-Symbol.replace.json b/test/fixtures/parser/literal/test262/String.prototype.replaceAll-and-Symbol.replace.json
new file mode 100644
index 0000000..9283a2a
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/String.prototype.replaceAll-and-Symbol.replace.json
@@ -0,0 +1,158 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/String/prototype/replaceAll/searchValue-tostring-regexp.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/./gi": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./gi",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "gi",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./gy": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./gy",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "gy",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./iyg": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/./iyg",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 6,
+          "raw": "iyg",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/Symbol.match-and-regexp-v-flag.json b/test/fixtures/parser/literal/test262/Symbol.match-and-regexp-v-flag.json
new file mode 100644
index 0000000..27bdf69
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/Symbol.match-and-regexp-v-flag.json
@@ -0,0 +1,170 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/String/prototype/match/regexp-prototype-match-v-flag.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/./gv": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./gv",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "gv",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/\\p{Script=Han}/gv": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/\\p{Script=Han}/gv",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "\\p{Script=Han}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "\\p{Script=Han}",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "\\p{Script=Han}",
+                  "kind": "property",
+                  "strings": false,
+                  "key": "Script",
+                  "value": "Han",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 18,
+          "raw": "gv",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/𠮷/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/𠮷/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "𠮷",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "𠮷",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "\ud842",
+                  "value": 55362
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "\udfb7",
+                  "value": 57271
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/Symbol.match.json b/test/fixtures/parser/literal/test262/Symbol.match.json
new file mode 100644
index 0000000..884968f
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/Symbol.match.json
@@ -0,0 +1,1147 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/prototype/Symbol.match/builtin-failure-g-set-lastindex-err.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/builtin-failure-y-return-val.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/builtin-infer-unicode.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/builtin-success-g-set-lastindex-err.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/builtin-success-return-val-groups.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/builtin-success-return-val.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/builtin-success-u-return-val-groups.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/coerce-arg.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/g-coerce-result-err.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/g-success-return-val.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/u-advance-after-empty.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/y-fail-global-return.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/y-fail-lastindex-no-write.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/y-fail-return.js",
+    "test/built-ins/RegExp/prototype/Symbol.match/y-set-lastindex.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/.(.)./g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/.(.)./g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": ".(.).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": ".(.).",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/./g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\udf06/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\udf06/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\udf06",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\udf06",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\udf06",
+                  "value": 57094
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\udf06/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/\\udf06/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\udf06",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\udf06",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\udf06",
+                  "value": 57094
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^|\\udf06/ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^|\\udf06/ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^|\\udf06",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "^",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 3,
+              "end": 9,
+              "raw": "\\udf06",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 9,
+                  "raw": "\\udf06",
+                  "value": 57094
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 12,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/a/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a/y": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/a/y",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "y",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a/yg": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/a/yg",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "yg",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/abc/y": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/abc/y",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "abc",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "abc",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "y",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b(.).(.)./": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/b(.).(.)./",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "b(.).(.).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "b(.).(.).",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 9,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b(.).(.)./u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/b(.).(.)./u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "b(.).(.).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "b(.).(.).",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 9,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b./": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/b./",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "b.",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "b.",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/b/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "b",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b/y": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/b/y",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "b",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "y",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/c/y": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/c/y",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "c",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "y",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/toString value/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/toString value/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "toString value",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "toString value",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "t",
+                  "value": 116
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "S",
+                  "value": 83
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "t",
+                  "value": 116
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "i",
+                  "value": 105
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "n",
+                  "value": 110
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "g",
+                  "value": 103
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": " ",
+                  "value": 32
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "v",
+                  "value": 118
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "l",
+                  "value": 108
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "u",
+                  "value": 117
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/Symbol.matchAll-and-regexp-unicode-property-escapes-and-regexp-v-flag.json b/test/fixtures/parser/literal/test262/Symbol.matchAll-and-regexp-unicode-property-escapes-and-regexp-v-flag.json
new file mode 100644
index 0000000..5aa6e7b
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/Symbol.matchAll-and-regexp-unicode-property-escapes-and-regexp-v-flag.json
@@ -0,0 +1,226 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/String/prototype/matchAll/regexp-prototype-matchAll-v-u-flag.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/(?:)/gu": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?:)/gu",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "(?:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "(?:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(?:)",
+                  "modifiers": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 4,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 8,
+          "raw": "gu",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\P{ASCII}/gu": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/\\P{ASCII}/gu",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "\\P{ASCII}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "\\P{ASCII}",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "\\P{ASCII}",
+                  "kind": "property",
+                  "strings": false,
+                  "key": "ASCII",
+                  "value": null,
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 13,
+          "raw": "gu",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\P{ASCII}/gv": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/\\P{ASCII}/gv",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "\\P{ASCII}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "\\P{ASCII}",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "\\P{ASCII}",
+                  "kind": "property",
+                  "strings": false,
+                  "key": "ASCII",
+                  "value": null,
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 13,
+          "raw": "gv",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/𠮷/gu": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/𠮷/gu",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "𠮷",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "𠮷",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "𠮷",
+                  "value": 134071
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 6,
+          "raw": "gu",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/Symbol.matchAll-and-regexp-v-flag.json b/test/fixtures/parser/literal/test262/Symbol.matchAll-and-regexp-v-flag.json
new file mode 100644
index 0000000..61060d5
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/Symbol.matchAll-and-regexp-v-flag.json
@@ -0,0 +1,118 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/String/prototype/matchAll/regexp-prototype-matchAll-v-flag.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/(?:)/gv": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?:)/gv",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "(?:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "(?:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(?:)",
+                  "modifiers": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 4,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 8,
+          "raw": "gv",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/𠮷/gv": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/𠮷/gv",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "𠮷",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "𠮷",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "𠮷",
+                  "value": 134071
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 6,
+          "raw": "gv",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/Symbol.replace-and-regexp-named-groups.json b/test/fixtures/parser/literal/test262/Symbol.replace-and-regexp-named-groups.json
new file mode 100644
index 0000000..09b5d4a
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/Symbol.replace-and-regexp-named-groups.json
@@ -0,0 +1,850 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/prototype/Symbol.replace/named-groups.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/(?<$𐒤>b)/gu": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?<$𐒤>b)/gu",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<$𐒤>b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<$𐒤>b)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<$𐒤>b)",
+                  "name": "$𐒤",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 13,
+          "raw": "gu",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<foo>.)(?<bar>.)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(?<foo>.)(?<bar>.)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?<foo>.)(?<bar>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?<foo>.)(?<bar>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<foo>.)",
+                  "name": "foo",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 19,
+                  "raw": "(?<bar>.)",
+                  "name": "bar",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 17,
+                      "end": 18,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 20,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<foo>.)(?<bar>.)/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?<foo>.)(?<bar>.)/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?<foo>.)(?<bar>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?<foo>.)(?<bar>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<foo>.)",
+                  "name": "foo",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 19,
+                  "raw": "(?<bar>.)",
+                  "name": "bar",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 17,
+                      "end": 18,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<foo>.)(?<bar>.)/gu": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(?<foo>.)(?<bar>.)/gu",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?<foo>.)(?<bar>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?<foo>.)(?<bar>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<foo>.)",
+                  "name": "foo",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 19,
+                  "raw": "(?<bar>.)",
+                  "name": "bar",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 17,
+                      "end": 18,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 22,
+          "raw": "gu",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<foo>.)/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?<foo>.)/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<foo>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<foo>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<foo>.)",
+                  "name": "foo",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<foo>.)/gu": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?<foo>.)/gu",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<foo>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<foo>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<foo>.)",
+                  "name": "foo",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 13,
+          "raw": "gu",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<foo>b)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?<foo>b)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<foo>b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<foo>b)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<foo>b)",
+                  "name": "foo",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<foo>b)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?<foo>b)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<foo>b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<foo>b)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<foo>b)",
+                  "name": "foo",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝒜>b)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?<𝒜>b)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?<𝒜>b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?<𝒜>b)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<𝒜>b)",
+                  "name": "𝒜",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(b)./": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/(b)./",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "(b).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "(b).",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(b)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/b/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "b",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/Symbol.replace.json b/test/fixtures/parser/literal/test262/Symbol.replace.json
new file mode 100644
index 0000000..69b9fc8
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/Symbol.replace.json
@@ -0,0 +1,995 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/prototype/Symbol.replace/coerce-unicode.js",
+    "test/built-ins/RegExp/prototype/Symbol.replace/fn-coerce-replacement-err.js",
+    "test/built-ins/RegExp/prototype/Symbol.replace/fn-invoke-args.js",
+    "test/built-ins/RegExp/prototype/Symbol.replace/replace-with-trailing.js",
+    "test/built-ins/RegExp/prototype/Symbol.replace/replace-without-trailing.js",
+    "test/built-ins/RegExp/prototype/Symbol.replace/subst-capture-idx-1.js",
+    "test/built-ins/RegExp/prototype/Symbol.replace/subst-matched.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/.4?./": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/.4?./",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": ".4?.",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": ".4?.",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "4?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 3,
+                    "raw": "4",
+                    "value": 52
+                  }
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^|\\udf06/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^|\\udf06/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^|\\udf06",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "^",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 3,
+              "end": 9,
+              "raw": "\\udf06",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 9,
+                  "raw": "\\udf06",
+                  "value": 57094
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/ab/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/ab/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "ab",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "ab",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/abc/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/abc/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "abc",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "abc",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/abcd/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/abcd/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "abcd",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "abcd",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b(.).(.)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/b(.).(.)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "b(.).(.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "b(.).(.)",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 9,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b(c)(z)?(.)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/b(c)(z)?(.)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "b(c)(z)?(.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "b(c)(z)?(.)",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(c)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "c",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 9,
+                  "raw": "(z)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 5,
+                    "end": 8,
+                    "raw": "(z)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 6,
+                        "end": 7,
+                        "raw": "z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "z",
+                            "value": 122
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 12,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 11,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 3,
+        "raw": "/b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "b",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 3,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/bc/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/bc/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "bc",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "bc",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/bcd/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/bcd/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "bcd",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "bcd",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 3,
+        "raw": "/c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "c",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 3,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/cd/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/cd/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "cd",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "cd",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/d/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 3,
+        "raw": "/d/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "d",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "d",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 3,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/x/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 3,
+        "raw": "/x/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "x",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "x",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "x",
+                  "value": 120
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 3,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/Symbol.search-and-regexp-v-flag.json b/test/fixtures/parser/literal/test262/Symbol.search-and-regexp-v-flag.json
new file mode 100644
index 0000000..dd05da2
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/Symbol.search-and-regexp-v-flag.json
@@ -0,0 +1,116 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/String/prototype/search/regexp-prototype-search-v-flag.js.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/a/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/a/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/b./v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/b./v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "b.",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "b.",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/Symbol.search.json b/test/fixtures/parser/literal/test262/Symbol.search.json
new file mode 100644
index 0000000..94ce80e
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/Symbol.search.json
@@ -0,0 +1,133 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/prototype/Symbol.search/coerce-string.js",
+    "test/built-ins/RegExp/prototype/Symbol.search/failure-return-val.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/ring/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/ring/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "ring",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "ring",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "i",
+                  "value": 105
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "n",
+                  "value": 110
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "g",
+                  "value": 103
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/z/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 3,
+        "raw": "/z/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "z",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "z",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "z",
+                  "value": 122
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 3,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/Symbol.species-and-Symbol.split.json b/test/fixtures/parser/literal/test262/Symbol.species-and-Symbol.split.json
new file mode 100644
index 0000000..7106745
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/Symbol.species-and-Symbol.split.json
@@ -0,0 +1,127 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/prototype/Symbol.split/species-ctor.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/[db]/y": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/[db]/y",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "[db]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "[db]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[db]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "d",
+                      "value": 100
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "b",
+                      "value": 98
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 7,
+          "raw": "y",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/x/iy": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/x/iy",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "x",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "x",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "x",
+                  "value": 120
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "iy",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/Symbol.split.json b/test/fixtures/parser/literal/test262/Symbol.split.json
new file mode 100644
index 0000000..4c54d1c
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/Symbol.split.json
@@ -0,0 +1,235 @@
+{
+  "_test262FileNames": [
+    "test/annexB/built-ins/RegExp/prototype/Symbol.split/toint32-limit-recompiles-source.js",
+    "test/built-ins/RegExp/prototype/Symbol.split/species-ctor-ctor-undef.js",
+    "test/built-ins/RegExp/prototype/Symbol.split/str-limit-capturing.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/[db]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/[db]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "[db]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "[db]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[db]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "d",
+                      "value": 100
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "b",
+                      "value": 98
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 3,
+        "raw": "/a/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 3,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/c(d)(e)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/c(d)(e)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "c(d)(e)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "c(d)(e)",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(d)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "d",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "d",
+                          "value": 100
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 8,
+                  "raw": "(e)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "e",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/class.json b/test/fixtures/parser/literal/test262/class.json
new file mode 100644
index 0000000..e22e91d
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/class.json
@@ -0,0 +1,58 @@
+{
+  "_test262FileNames": [
+    "test/language/statementList/class-regexp-literal-flags.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/1/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/1/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "1",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "1",
+                  "value": 49
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/generators.json b/test/fixtures/parser/literal/test262/generators.json
new file mode 100644
index 0000000..b889216
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/generators.json
@@ -0,0 +1,277 @@
+{
+  "_test262FileNames": [
+    "test/annexB/built-ins/RegExp/RegExp-control-escape-russian-letter.js",
+    "test/language/expressions/yield/rhs-regexp.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/[0-9A-Za-z_\\$(|)\\[\\]\\/\\\\^]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/[0-9A-Za-z_\\$(|)\\[\\]\\/\\\\^]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "[0-9A-Za-z_\\$(|)\\[\\]\\/\\\\^]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "[0-9A-Za-z_\\$(|)\\[\\]\\/\\\\^]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 27,
+                  "raw": "[0-9A-Za-z_\\$(|)\\[\\]\\/\\\\^]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "0-9",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "0",
+                        "value": 48
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "9",
+                        "value": 57
+                      }
+                    },
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "A-Z",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "A",
+                        "value": 65
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 8,
+                        "raw": "Z",
+                        "value": 90
+                      }
+                    },
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 11,
+                      "raw": "a-z",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 8,
+                        "end": 9,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 11,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 12,
+                      "raw": "_",
+                      "value": 95
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 14,
+                      "raw": "\\$",
+                      "value": 36
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 15,
+                      "raw": "(",
+                      "value": 40
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 15,
+                      "end": 16,
+                      "raw": "|",
+                      "value": 124
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 17,
+                      "raw": ")",
+                      "value": 41
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 17,
+                      "end": 19,
+                      "raw": "\\[",
+                      "value": 91
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 19,
+                      "end": 21,
+                      "raw": "\\]",
+                      "value": 93
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 21,
+                      "end": 23,
+                      "raw": "\\/",
+                      "value": 47
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 23,
+                      "end": 25,
+                      "raw": "\\\\",
+                      "value": 92
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 25,
+                      "end": 26,
+                      "raw": "^",
+                      "value": 94
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 28,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/abc/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/abc/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "abc",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "abc",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/legacy-regexp.json b/test/fixtures/parser/literal/test262/legacy-regexp.json
new file mode 100644
index 0000000..d051f02
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/legacy-regexp.json
@@ -0,0 +1,58 @@
+{
+  "_test262FileNames": [
+    "test/annexB/built-ins/RegExp/legacy-accessors/index/this-not-regexp-constructor.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/ /": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 3,
+        "raw": "/ /",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": " ",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": " ",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": " ",
+                  "value": 32
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 3,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/not-categorized.json b/test/fixtures/parser/literal/test262/not-categorized.json
new file mode 100644
index 0000000..dc72c2b
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/not-categorized.json
@@ -0,0 +1,36222 @@
+{
+  "_test262FileNames": [
+    "test/annexB/built-ins/RegExp/RegExp-decimal-escape-not-capturing.js",
+    "test/annexB/built-ins/RegExp/RegExp-invalid-control-escape-character-class-range.js",
+    "test/annexB/built-ins/RegExp/RegExp-trailing-escape.js",
+    "test/annexB/built-ins/RegExp/incomplete_hex_unicode_escape.js",
+    "test/annexB/built-ins/RegExp/prototype/compile/flags-string-invalid.js",
+    "test/annexB/built-ins/RegExp/prototype/compile/flags-undefined.js",
+    "test/annexB/built-ins/RegExp/prototype/compile/pattern-regexp-distinct.js",
+    "test/annexB/built-ins/RegExp/prototype/compile/pattern-regexp-immutable-lastindex.js",
+    "test/annexB/built-ins/RegExp/prototype/compile/pattern-regexp-props.js",
+    "test/annexB/built-ins/RegExp/prototype/compile/pattern-string-invalid-u.js",
+    "test/annexB/built-ins/RegExp/prototype/compile/pattern-string-u.js",
+    "test/annexB/language/literals/regexp/class-escape.js",
+    "test/annexB/language/literals/regexp/extended-pattern-char.js",
+    "test/annexB/language/literals/regexp/identity-escape.js",
+    "test/annexB/language/literals/regexp/legacy-octal-escape.js",
+    "test/annexB/language/literals/regexp/non-empty-class-ranges-no-dash.js",
+    "test/annexB/language/literals/regexp/non-empty-class-ranges.js",
+    "test/annexB/language/literals/regexp/quantifiable-assertion-followed-by.js",
+    "test/annexB/language/literals/regexp/quantifiable-assertion-not-followed-by.js",
+    "test/built-ins/Object/internals/DefineOwnProperty/consistent-value-regexp-dollar1.js",
+    "test/built-ins/RegExp/S15.10.2.10_A1.1_T1.js",
+    "test/built-ins/RegExp/S15.10.2.10_A1.2_T1.js",
+    "test/built-ins/RegExp/S15.10.2.10_A1.3_T1.js",
+    "test/built-ins/RegExp/S15.10.2.10_A1.4_T1.js",
+    "test/built-ins/RegExp/S15.10.2.10_A1.5_T1.js",
+    "test/built-ins/RegExp/S15.10.2.10_A3.1_T1.js",
+    "test/built-ins/RegExp/S15.10.2.10_A4.1_T1.js",
+    "test/built-ins/RegExp/S15.10.2.11_A1_T4.js",
+    "test/built-ins/RegExp/S15.10.2.11_A1_T5.js",
+    "test/built-ins/RegExp/S15.10.2.11_A1_T6.js",
+    "test/built-ins/RegExp/S15.10.2.11_A1_T7.js",
+    "test/built-ins/RegExp/S15.10.2.11_A1_T8.js",
+    "test/built-ins/RegExp/S15.10.2.11_A1_T9.js",
+    "test/built-ins/RegExp/S15.10.2.13_A1_T1.js",
+    "test/built-ins/RegExp/S15.10.2.13_A1_T10.js",
+    "test/built-ins/RegExp/S15.10.2.13_A1_T11.js",
+    "test/built-ins/RegExp/S15.10.2.13_A1_T12.js",
+    "test/built-ins/RegExp/S15.10.2.13_A1_T13.js",
+    "test/built-ins/RegExp/S15.10.2.13_A1_T14.js",
+    "test/built-ins/RegExp/S15.10.2.13_A1_T15.js",
+    "test/built-ins/RegExp/S15.10.2.13_A1_T2.js",
+    "test/built-ins/RegExp/S15.10.2.13_A1_T3.js",
+    "test/built-ins/RegExp/S15.10.2.13_A1_T6.js",
+    "test/built-ins/RegExp/S15.10.2.13_A1_T7.js",
+    "test/built-ins/RegExp/S15.10.2.13_A1_T8.js",
+    "test/built-ins/RegExp/S15.10.2.13_A1_T9.js",
+    "test/built-ins/RegExp/S15.10.2.13_A2_T1.js",
+    "test/built-ins/RegExp/S15.10.2.13_A2_T2.js",
+    "test/built-ins/RegExp/S15.10.2.13_A2_T3.js",
+    "test/built-ins/RegExp/S15.10.2.13_A2_T4.js",
+    "test/built-ins/RegExp/S15.10.2.13_A2_T5.js",
+    "test/built-ins/RegExp/S15.10.2.13_A2_T6.js",
+    "test/built-ins/RegExp/S15.10.2.13_A2_T7.js",
+    "test/built-ins/RegExp/S15.10.2.13_A2_T8.js",
+    "test/built-ins/RegExp/S15.10.2.13_A3_T1.js",
+    "test/built-ins/RegExp/S15.10.2.13_A3_T2.js",
+    "test/built-ins/RegExp/S15.10.2.13_A3_T3.js",
+    "test/built-ins/RegExp/S15.10.2.3_A1_T1.js",
+    "test/built-ins/RegExp/S15.10.2.3_A1_T10.js",
+    "test/built-ins/RegExp/S15.10.2.3_A1_T11.js",
+    "test/built-ins/RegExp/S15.10.2.3_A1_T12.js",
+    "test/built-ins/RegExp/S15.10.2.3_A1_T13.js",
+    "test/built-ins/RegExp/S15.10.2.3_A1_T14.js",
+    "test/built-ins/RegExp/S15.10.2.3_A1_T15.js",
+    "test/built-ins/RegExp/S15.10.2.3_A1_T16.js",
+    "test/built-ins/RegExp/S15.10.2.3_A1_T17.js",
+    "test/built-ins/RegExp/S15.10.2.3_A1_T2.js",
+    "test/built-ins/RegExp/S15.10.2.3_A1_T3.js",
+    "test/built-ins/RegExp/S15.10.2.3_A1_T6.js",
+    "test/built-ins/RegExp/S15.10.2.3_A1_T7.js",
+    "test/built-ins/RegExp/S15.10.2.5_A1_T1.js",
+    "test/built-ins/RegExp/S15.10.2.5_A1_T2.js",
+    "test/built-ins/RegExp/S15.10.2.5_A1_T3.js",
+    "test/built-ins/RegExp/S15.10.2.5_A1_T4.js",
+    "test/built-ins/RegExp/S15.10.2.5_A1_T5.js",
+    "test/built-ins/RegExp/S15.10.2.6_A1_T1.js",
+    "test/built-ins/RegExp/S15.10.2.6_A1_T2.js",
+    "test/built-ins/RegExp/S15.10.2.6_A1_T3.js",
+    "test/built-ins/RegExp/S15.10.2.6_A1_T4.js",
+    "test/built-ins/RegExp/S15.10.2.6_A1_T5.js",
+    "test/built-ins/RegExp/S15.10.2.6_A2_T1.js",
+    "test/built-ins/RegExp/S15.10.2.6_A2_T10.js",
+    "test/built-ins/RegExp/S15.10.2.6_A2_T2.js",
+    "test/built-ins/RegExp/S15.10.2.6_A2_T3.js",
+    "test/built-ins/RegExp/S15.10.2.6_A2_T4.js",
+    "test/built-ins/RegExp/S15.10.2.6_A2_T5.js",
+    "test/built-ins/RegExp/S15.10.2.6_A2_T6.js",
+    "test/built-ins/RegExp/S15.10.2.6_A2_T7.js",
+    "test/built-ins/RegExp/S15.10.2.6_A2_T8.js",
+    "test/built-ins/RegExp/S15.10.2.6_A2_T9.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T1.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T10.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T11.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T12.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T13.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T14.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T15.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T2.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T3.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T4.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T5.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T6.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T7.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T8.js",
+    "test/built-ins/RegExp/S15.10.2.6_A3_T9.js",
+    "test/built-ins/RegExp/S15.10.2.6_A4_T1.js",
+    "test/built-ins/RegExp/S15.10.2.6_A4_T2.js",
+    "test/built-ins/RegExp/S15.10.2.6_A4_T3.js",
+    "test/built-ins/RegExp/S15.10.2.6_A4_T4.js",
+    "test/built-ins/RegExp/S15.10.2.6_A4_T5.js",
+    "test/built-ins/RegExp/S15.10.2.6_A4_T6.js",
+    "test/built-ins/RegExp/S15.10.2.6_A4_T7.js",
+    "test/built-ins/RegExp/S15.10.2.6_A4_T8.js",
+    "test/built-ins/RegExp/S15.10.2.6_A5_T1.js",
+    "test/built-ins/RegExp/S15.10.2.6_A5_T2.js",
+    "test/built-ins/RegExp/S15.10.2.6_A6_T1.js",
+    "test/built-ins/RegExp/S15.10.2.6_A6_T2.js",
+    "test/built-ins/RegExp/S15.10.2.6_A6_T3.js",
+    "test/built-ins/RegExp/S15.10.2.6_A6_T4.js",
+    "test/built-ins/RegExp/S15.10.2.7_A1_T1.js",
+    "test/built-ins/RegExp/S15.10.2.7_A1_T10.js",
+    "test/built-ins/RegExp/S15.10.2.7_A1_T11.js",
+    "test/built-ins/RegExp/S15.10.2.7_A1_T12.js",
+    "test/built-ins/RegExp/S15.10.2.7_A1_T8.js",
+    "test/built-ins/RegExp/S15.10.2.7_A1_T9.js",
+    "test/built-ins/RegExp/S15.10.2.7_A2_T1.js",
+    "test/built-ins/RegExp/S15.10.2.7_A2_T3.js",
+    "test/built-ins/RegExp/S15.10.2.7_A2_T4.js",
+    "test/built-ins/RegExp/S15.10.2.7_A3_T1.js",
+    "test/built-ins/RegExp/S15.10.2.7_A3_T10.js",
+    "test/built-ins/RegExp/S15.10.2.7_A3_T11.js",
+    "test/built-ins/RegExp/S15.10.2.7_A3_T12.js",
+    "test/built-ins/RegExp/S15.10.2.7_A3_T13.js",
+    "test/built-ins/RegExp/S15.10.2.7_A3_T14.js",
+    "test/built-ins/RegExp/S15.10.2.7_A3_T5.js",
+    "test/built-ins/RegExp/S15.10.2.7_A3_T7.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T1.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T10.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T11.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T12.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T13.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T14.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T15.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T16.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T17.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T18.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T19.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T20.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T21.js",
+    "test/built-ins/RegExp/S15.10.2.7_A4_T6.js",
+    "test/built-ins/RegExp/S15.10.2.7_A5_T1.js",
+    "test/built-ins/RegExp/S15.10.2.7_A5_T10.js",
+    "test/built-ins/RegExp/S15.10.2.7_A5_T11.js",
+    "test/built-ins/RegExp/S15.10.2.7_A5_T12.js",
+    "test/built-ins/RegExp/S15.10.2.7_A5_T4.js",
+    "test/built-ins/RegExp/S15.10.2.7_A5_T5.js",
+    "test/built-ins/RegExp/S15.10.2.7_A5_T6.js",
+    "test/built-ins/RegExp/S15.10.2.7_A5_T7.js",
+    "test/built-ins/RegExp/S15.10.2.7_A5_T8.js",
+    "test/built-ins/RegExp/S15.10.2.7_A5_T9.js",
+    "test/built-ins/RegExp/S15.10.2.7_A6_T1.js",
+    "test/built-ins/RegExp/S15.10.2.7_A6_T2.js",
+    "test/built-ins/RegExp/S15.10.2.7_A6_T3.js",
+    "test/built-ins/RegExp/S15.10.2.7_A6_T4.js",
+    "test/built-ins/RegExp/S15.10.2.7_A6_T5.js",
+    "test/built-ins/RegExp/S15.10.2.7_A6_T6.js",
+    "test/built-ins/RegExp/S15.10.2.8_A1_T1.js",
+    "test/built-ins/RegExp/S15.10.2.8_A1_T2.js",
+    "test/built-ins/RegExp/S15.10.2.8_A1_T3.js",
+    "test/built-ins/RegExp/S15.10.2.8_A2_T1.js",
+    "test/built-ins/RegExp/S15.10.2.8_A2_T10.js",
+    "test/built-ins/RegExp/S15.10.2.8_A2_T2.js",
+    "test/built-ins/RegExp/S15.10.2.8_A2_T6.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T1.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T10.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T11.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T12.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T13.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T14.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T17.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T18.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T19.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T20.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T23.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T26.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T27.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T28.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T29.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T32.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T33.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T4.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T5.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T6.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T7.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T8.js",
+    "test/built-ins/RegExp/S15.10.2.8_A3_T9.js",
+    "test/built-ins/RegExp/S15.10.2.8_A4_T1.js",
+    "test/built-ins/RegExp/S15.10.2.8_A4_T2.js",
+    "test/built-ins/RegExp/S15.10.2.8_A4_T3.js",
+    "test/built-ins/RegExp/S15.10.2.8_A5_T1.js",
+    "test/built-ins/RegExp/S15.10.2.8_A5_T2.js",
+    "test/built-ins/RegExp/S15.10.2.9_A1_T1.js",
+    "test/built-ins/RegExp/S15.10.2.9_A1_T2.js",
+    "test/built-ins/RegExp/S15.10.3.1_A1_T1.js",
+    "test/built-ins/RegExp/S15.10.3.1_A1_T5.js",
+    "test/built-ins/RegExp/S15.10.3.1_A2_T2.js",
+    "test/built-ins/RegExp/S15.10.4.1_A1_T2.js",
+    "test/built-ins/RegExp/S15.10.4.1_A1_T3.js",
+    "test/built-ins/RegExp/S15.10.4.1_A2_T1.js",
+    "test/built-ins/RegExp/S15.10.4.1_A2_T2.js",
+    "test/built-ins/RegExp/S15.10.7_A1_T1.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T1.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T11.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T12.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T13.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T14.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T15.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T16.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T17.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T18.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T19.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T2.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T20.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T21.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T7.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A3_T1.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A3_T2.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A3_T3.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A3_T4.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A3_T6.js",
+    "test/built-ins/RegExp/prototype/exec/S15.10.6.2_A3_T7.js",
+    "test/built-ins/RegExp/prototype/exec/u-lastindex-value.js",
+    "test/built-ins/RegExp/prototype/global/S15.10.7.2_A10.js",
+    "test/built-ins/RegExp/prototype/ignoreCase/S15.10.7.3_A10.js",
+    "test/built-ins/RegExp/prototype/source/value-u.js",
+    "test/built-ins/RegExp/prototype/source/value.js",
+    "test/built-ins/RegExp/prototype/sticky/this-val-regexp.js",
+    "test/built-ins/RegExp/prototype/unicode/this-val-regexp.js",
+    "test/built-ins/RegExp/regexp-class-chars.js",
+    "test/built-ins/RegExp/unicode_character_class_backspace_escape.js",
+    "test/built-ins/RegExp/unicode_full_case_folding.js",
+    "test/built-ins/RegExp/unicode_identity_escape.js",
+    "test/built-ins/String/prototype/split/argument-is-regexp-and-instance-is-number.js",
+    "test/built-ins/String/prototype/split/argument-is-regexp-l-and-instance-is-string-hello.js",
+    "test/built-ins/String/prototype/split/argument-is-regexp-x-and-instance-is-string-a-b-c-de-f.js",
+    "test/built-ins/String/prototype/split/separator-regexp-comma-instance-is-string-one-1-two-2-four-4.js",
+    "test/built-ins/String/prototype/split/separator-regexp.js",
+    "test/language/literals/regexp/S7.8.5_A1.1_T1.js",
+    "test/language/literals/regexp/S7.8.5_A1.4_T1.js",
+    "test/language/literals/regexp/S7.8.5_A1.5_T1.js",
+    "test/language/literals/regexp/S7.8.5_A2.1_T1.js",
+    "test/language/literals/regexp/S7.8.5_A2.2_T1.js",
+    "test/language/literals/regexp/S7.8.5_A2.3_T1.js",
+    "test/language/literals/regexp/S7.8.5_A2.4_T1.js",
+    "test/language/literals/regexp/S7.8.5_A2.5_T1.js",
+    "test/language/literals/regexp/invalid-braced-quantifier-exact.js",
+    "test/language/literals/regexp/invalid-braced-quantifier-lower.js",
+    "test/language/literals/regexp/invalid-braced-quantifier-range.js",
+    "test/language/literals/regexp/invalid-optional-lookbehind.js",
+    "test/language/literals/regexp/invalid-optional-negative-lookbehind.js",
+    "test/language/literals/regexp/invalid-range-lookbehind.js",
+    "test/language/literals/regexp/invalid-range-negative-lookbehind.js",
+    "test/language/literals/regexp/regexp-source-char-no-line-separator.js",
+    "test/language/literals/regexp/u-astral-char-class-invert.js",
+    "test/language/literals/regexp/u-astral.js",
+    "test/language/literals/regexp/u-case-mapping.js",
+    "test/language/literals/regexp/u-invalid-class-escape.js",
+    "test/language/literals/regexp/u-invalid-identity-escape.js",
+    "test/language/literals/regexp/u-invalid-non-empty-class-ranges-no-dash-a.js",
+    "test/language/literals/regexp/u-invalid-non-empty-class-ranges-no-dash-ab.js",
+    "test/language/literals/regexp/u-invalid-non-empty-class-ranges-no-dash-b.js",
+    "test/language/literals/regexp/u-invalid-non-empty-class-ranges.js",
+    "test/language/literals/regexp/u-invalid-oob-decimal-escape.js",
+    "test/language/literals/regexp/u-invalid-optional-lookahead.js",
+    "test/language/literals/regexp/u-invalid-optional-lookbehind.js",
+    "test/language/literals/regexp/u-invalid-optional-negative-lookahead.js",
+    "test/language/literals/regexp/u-invalid-optional-negative-lookbehind.js",
+    "test/language/literals/regexp/u-invalid-range-lookahead.js",
+    "test/language/literals/regexp/u-invalid-range-lookbehind.js",
+    "test/language/literals/regexp/u-invalid-range-negative-lookahead.js",
+    "test/language/literals/regexp/u-invalid-range-negative-lookbehind.js",
+    "test/language/literals/regexp/u-null-character-escape.js",
+    "test/language/literals/regexp/u-surrogate-pairs-atom-char-class.js",
+    "test/language/literals/regexp/u-surrogate-pairs-atom-escape-char-class.js",
+    "test/language/literals/regexp/u-surrogate-pairs-atom-escape-decimal.js",
+    "test/language/literals/regexp/u-surrogate-pairs.js",
+    "test/language/literals/regexp/u-unicode-esc-non-hex.js",
+    "test/language/literals/regexp/u-unicode-esc.js",
+    "test/language/literals/regexp/y-assertion-start.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/  /": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/  /",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "  ",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "  ",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": " ",
+                  "value": 32
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": " ",
+                  "value": 32
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/ \\ /": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/ \\ /",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": " \\ ",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": " \\ ",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": " ",
+                  "value": 32
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "\\ ",
+                  "value": 32
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/((((((((((A))))))))))\\10\\9\\8\\7\\6\\5\\4\\3\\2\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/((((((((((A))))))))))\\10\\9\\8\\7\\6\\5\\4\\3\\2\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 43,
+          "raw": "((((((((((A))))))))))\\10\\9\\8\\7\\6\\5\\4\\3\\2\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 43,
+              "raw": "((((((((((A))))))))))\\10\\9\\8\\7\\6\\5\\4\\3\\2\\1",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 22,
+                  "raw": "((((((((((A))))))))))",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 21,
+                      "raw": "(((((((((A)))))))))",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 21,
+                          "raw": "(((((((((A)))))))))",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 3,
+                              "end": 20,
+                              "raw": "((((((((A))))))))",
+                              "elements": [
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 3,
+                                  "end": 20,
+                                  "raw": "((((((((A))))))))",
+                                  "name": null,
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 4,
+                                      "end": 19,
+                                      "raw": "(((((((A)))))))",
+                                      "elements": [
+                                        {
+                                          "type": "CapturingGroup",
+                                          "parent": "♻️../..",
+                                          "start": 4,
+                                          "end": 19,
+                                          "raw": "(((((((A)))))))",
+                                          "name": null,
+                                          "alternatives": [
+                                            {
+                                              "type": "Alternative",
+                                              "parent": "♻️../..",
+                                              "start": 5,
+                                              "end": 18,
+                                              "raw": "((((((A))))))",
+                                              "elements": [
+                                                {
+                                                  "type": "CapturingGroup",
+                                                  "parent": "♻️../..",
+                                                  "start": 5,
+                                                  "end": 18,
+                                                  "raw": "((((((A))))))",
+                                                  "name": null,
+                                                  "alternatives": [
+                                                    {
+                                                      "type": "Alternative",
+                                                      "parent": "♻️../..",
+                                                      "start": 6,
+                                                      "end": 17,
+                                                      "raw": "(((((A)))))",
+                                                      "elements": [
+                                                        {
+                                                          "type": "CapturingGroup",
+                                                          "parent": "♻️../..",
+                                                          "start": 6,
+                                                          "end": 17,
+                                                          "raw": "(((((A)))))",
+                                                          "name": null,
+                                                          "alternatives": [
+                                                            {
+                                                              "type": "Alternative",
+                                                              "parent": "♻️../..",
+                                                              "start": 7,
+                                                              "end": 16,
+                                                              "raw": "((((A))))",
+                                                              "elements": [
+                                                                {
+                                                                  "type": "CapturingGroup",
+                                                                  "parent": "♻️../..",
+                                                                  "start": 7,
+                                                                  "end": 16,
+                                                                  "raw": "((((A))))",
+                                                                  "name": null,
+                                                                  "alternatives": [
+                                                                    {
+                                                                      "type": "Alternative",
+                                                                      "parent": "♻️../..",
+                                                                      "start": 8,
+                                                                      "end": 15,
+                                                                      "raw": "(((A)))",
+                                                                      "elements": [
+                                                                        {
+                                                                          "type": "CapturingGroup",
+                                                                          "parent": "♻️../..",
+                                                                          "start": 8,
+                                                                          "end": 15,
+                                                                          "raw": "(((A)))",
+                                                                          "name": null,
+                                                                          "alternatives": [
+                                                                            {
+                                                                              "type": "Alternative",
+                                                                              "parent": "♻️../..",
+                                                                              "start": 9,
+                                                                              "end": 14,
+                                                                              "raw": "((A))",
+                                                                              "elements": [
+                                                                                {
+                                                                                  "type": "CapturingGroup",
+                                                                                  "parent": "♻️../..",
+                                                                                  "start": 9,
+                                                                                  "end": 14,
+                                                                                  "raw": "((A))",
+                                                                                  "name": null,
+                                                                                  "alternatives": [
+                                                                                    {
+                                                                                      "type": "Alternative",
+                                                                                      "parent": "♻️../..",
+                                                                                      "start": 10,
+                                                                                      "end": 13,
+                                                                                      "raw": "(A)",
+                                                                                      "elements": [
+                                                                                        {
+                                                                                          "type": "CapturingGroup",
+                                                                                          "parent": "♻️../..",
+                                                                                          "start": 10,
+                                                                                          "end": 13,
+                                                                                          "raw": "(A)",
+                                                                                          "name": null,
+                                                                                          "alternatives": [
+                                                                                            {
+                                                                                              "type": "Alternative",
+                                                                                              "parent": "♻️../..",
+                                                                                              "start": 11,
+                                                                                              "end": 12,
+                                                                                              "raw": "A",
+                                                                                              "elements": [
+                                                                                                {
+                                                                                                  "type": "Character",
+                                                                                                  "parent": "♻️../..",
+                                                                                                  "start": 11,
+                                                                                                  "end": 12,
+                                                                                                  "raw": "A",
+                                                                                                  "value": 65
+                                                                                                }
+                                                                                              ]
+                                                                                            }
+                                                                                          ],
+                                                                                          "references": [
+                                                                                            "♻️../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../1"
+                                                                                          ]
+                                                                                        }
+                                                                                      ]
+                                                                                    }
+                                                                                  ],
+                                                                                  "references": [
+                                                                                    "♻️../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../2"
+                                                                                  ]
+                                                                                }
+                                                                              ]
+                                                                            }
+                                                                          ],
+                                                                          "references": [
+                                                                            "♻️../../../../../../../../../../../../../../../../../../../../../../../../../../../../../3"
+                                                                          ]
+                                                                        }
+                                                                      ]
+                                                                    }
+                                                                  ],
+                                                                  "references": [
+                                                                    "♻️../../../../../../../../../../../../../../../../../../../../../../../../../4"
+                                                                  ]
+                                                                }
+                                                              ]
+                                                            }
+                                                          ],
+                                                          "references": [
+                                                            "♻️../../../../../../../../../../../../../../../../../../../../../5"
+                                                          ]
+                                                        }
+                                                      ]
+                                                    }
+                                                  ],
+                                                  "references": [
+                                                    "♻️../../../../../../../../../../../../../../../../../6"
+                                                  ]
+                                                }
+                                              ]
+                                            }
+                                          ],
+                                          "references": [
+                                            "♻️../../../../../../../../../../../../../7"
+                                          ]
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": [
+                                    "♻️../../../../../../../../../8"
+                                  ]
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../9"
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../10"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 25,
+                  "raw": "\\10",
+                  "ref": 10,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 27,
+                  "raw": "\\9",
+                  "ref": 9,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 29,
+                  "raw": "\\8",
+                  "ref": 8,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 31,
+                  "raw": "\\7",
+                  "ref": 7,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 33,
+                  "raw": "\\6",
+                  "ref": 6,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 35,
+                  "raw": "\\5",
+                  "ref": 5,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 37,
+                  "raw": "\\4",
+                  "ref": 4,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 39,
+                  "raw": "\\3",
+                  "ref": 3,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 39,
+                  "end": 41,
+                  "raw": "\\2",
+                  "ref": 2,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 41,
+                  "end": 43,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 44,
+          "end": 44,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/((((((((((A))))))))))\\1\\2\\3\\4\\5\\6\\7\\8\\9\\10/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/((((((((((A))))))))))\\1\\2\\3\\4\\5\\6\\7\\8\\9\\10/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 43,
+          "raw": "((((((((((A))))))))))\\1\\2\\3\\4\\5\\6\\7\\8\\9\\10",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 43,
+              "raw": "((((((((((A))))))))))\\1\\2\\3\\4\\5\\6\\7\\8\\9\\10",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 22,
+                  "raw": "((((((((((A))))))))))",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 21,
+                      "raw": "(((((((((A)))))))))",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 21,
+                          "raw": "(((((((((A)))))))))",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 3,
+                              "end": 20,
+                              "raw": "((((((((A))))))))",
+                              "elements": [
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 3,
+                                  "end": 20,
+                                  "raw": "((((((((A))))))))",
+                                  "name": null,
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 4,
+                                      "end": 19,
+                                      "raw": "(((((((A)))))))",
+                                      "elements": [
+                                        {
+                                          "type": "CapturingGroup",
+                                          "parent": "♻️../..",
+                                          "start": 4,
+                                          "end": 19,
+                                          "raw": "(((((((A)))))))",
+                                          "name": null,
+                                          "alternatives": [
+                                            {
+                                              "type": "Alternative",
+                                              "parent": "♻️../..",
+                                              "start": 5,
+                                              "end": 18,
+                                              "raw": "((((((A))))))",
+                                              "elements": [
+                                                {
+                                                  "type": "CapturingGroup",
+                                                  "parent": "♻️../..",
+                                                  "start": 5,
+                                                  "end": 18,
+                                                  "raw": "((((((A))))))",
+                                                  "name": null,
+                                                  "alternatives": [
+                                                    {
+                                                      "type": "Alternative",
+                                                      "parent": "♻️../..",
+                                                      "start": 6,
+                                                      "end": 17,
+                                                      "raw": "(((((A)))))",
+                                                      "elements": [
+                                                        {
+                                                          "type": "CapturingGroup",
+                                                          "parent": "♻️../..",
+                                                          "start": 6,
+                                                          "end": 17,
+                                                          "raw": "(((((A)))))",
+                                                          "name": null,
+                                                          "alternatives": [
+                                                            {
+                                                              "type": "Alternative",
+                                                              "parent": "♻️../..",
+                                                              "start": 7,
+                                                              "end": 16,
+                                                              "raw": "((((A))))",
+                                                              "elements": [
+                                                                {
+                                                                  "type": "CapturingGroup",
+                                                                  "parent": "♻️../..",
+                                                                  "start": 7,
+                                                                  "end": 16,
+                                                                  "raw": "((((A))))",
+                                                                  "name": null,
+                                                                  "alternatives": [
+                                                                    {
+                                                                      "type": "Alternative",
+                                                                      "parent": "♻️../..",
+                                                                      "start": 8,
+                                                                      "end": 15,
+                                                                      "raw": "(((A)))",
+                                                                      "elements": [
+                                                                        {
+                                                                          "type": "CapturingGroup",
+                                                                          "parent": "♻️../..",
+                                                                          "start": 8,
+                                                                          "end": 15,
+                                                                          "raw": "(((A)))",
+                                                                          "name": null,
+                                                                          "alternatives": [
+                                                                            {
+                                                                              "type": "Alternative",
+                                                                              "parent": "♻️../..",
+                                                                              "start": 9,
+                                                                              "end": 14,
+                                                                              "raw": "((A))",
+                                                                              "elements": [
+                                                                                {
+                                                                                  "type": "CapturingGroup",
+                                                                                  "parent": "♻️../..",
+                                                                                  "start": 9,
+                                                                                  "end": 14,
+                                                                                  "raw": "((A))",
+                                                                                  "name": null,
+                                                                                  "alternatives": [
+                                                                                    {
+                                                                                      "type": "Alternative",
+                                                                                      "parent": "♻️../..",
+                                                                                      "start": 10,
+                                                                                      "end": 13,
+                                                                                      "raw": "(A)",
+                                                                                      "elements": [
+                                                                                        {
+                                                                                          "type": "CapturingGroup",
+                                                                                          "parent": "♻️../..",
+                                                                                          "start": 10,
+                                                                                          "end": 13,
+                                                                                          "raw": "(A)",
+                                                                                          "name": null,
+                                                                                          "alternatives": [
+                                                                                            {
+                                                                                              "type": "Alternative",
+                                                                                              "parent": "♻️../..",
+                                                                                              "start": 11,
+                                                                                              "end": 12,
+                                                                                              "raw": "A",
+                                                                                              "elements": [
+                                                                                                {
+                                                                                                  "type": "Character",
+                                                                                                  "parent": "♻️../..",
+                                                                                                  "start": 11,
+                                                                                                  "end": 12,
+                                                                                                  "raw": "A",
+                                                                                                  "value": 65
+                                                                                                }
+                                                                                              ]
+                                                                                            }
+                                                                                          ],
+                                                                                          "references": [
+                                                                                            "♻️../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../10"
+                                                                                          ]
+                                                                                        }
+                                                                                      ]
+                                                                                    }
+                                                                                  ],
+                                                                                  "references": [
+                                                                                    "♻️../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../9"
+                                                                                  ]
+                                                                                }
+                                                                              ]
+                                                                            }
+                                                                          ],
+                                                                          "references": [
+                                                                            "♻️../../../../../../../../../../../../../../../../../../../../../../../../../../../../../8"
+                                                                          ]
+                                                                        }
+                                                                      ]
+                                                                    }
+                                                                  ],
+                                                                  "references": [
+                                                                    "♻️../../../../../../../../../../../../../../../../../../../../../../../../../7"
+                                                                  ]
+                                                                }
+                                                              ]
+                                                            }
+                                                          ],
+                                                          "references": [
+                                                            "♻️../../../../../../../../../../../../../../../../../../../../../6"
+                                                          ]
+                                                        }
+                                                      ]
+                                                    }
+                                                  ],
+                                                  "references": [
+                                                    "♻️../../../../../../../../../../../../../../../../../5"
+                                                  ]
+                                                }
+                                              ]
+                                            }
+                                          ],
+                                          "references": [
+                                            "♻️../../../../../../../../../../../../../4"
+                                          ]
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": [
+                                    "♻️../../../../../../../../../3"
+                                  ]
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../2"
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 24,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 26,
+                  "raw": "\\2",
+                  "ref": 2,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 28,
+                  "raw": "\\3",
+                  "ref": 3,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 30,
+                  "raw": "\\4",
+                  "ref": 4,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 32,
+                  "raw": "\\5",
+                  "ref": 5,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 34,
+                  "raw": "\\6",
+                  "ref": 6,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 36,
+                  "raw": "\\7",
+                  "ref": 7,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 38,
+                  "raw": "\\8",
+                  "ref": 8,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 40,
+                  "raw": "\\9",
+                  "ref": 9,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 43,
+                  "raw": "\\10",
+                  "ref": 10,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0/alternatives/0/elements/0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 44,
+          "end": 44,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/((1)|(12))((3)|(23))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/((1)|(12))((3)|(23))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "((1)|(12))((3)|(23))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "((1)|(12))((3)|(23))",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "((1)|(12))",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "(1)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 5,
+                          "raw": "(1)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 3,
+                              "end": 4,
+                              "raw": "1",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 3,
+                                  "end": 4,
+                                  "raw": "1",
+                                  "value": 49
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": "(12)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 10,
+                          "raw": "(12)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 9,
+                              "raw": "12",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "1",
+                                  "value": 49
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 9,
+                                  "raw": "2",
+                                  "value": 50
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 21,
+                  "raw": "((3)|(23))",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 15,
+                      "raw": "(3)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 15,
+                          "raw": "(3)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 13,
+                              "end": 14,
+                              "raw": "3",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "3",
+                                  "value": 51
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 20,
+                      "raw": "(23)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 20,
+                          "raw": "(23)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 17,
+                              "end": 19,
+                              "raw": "23",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 17,
+                                  "end": 18,
+                                  "raw": "2",
+                                  "value": 50
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 18,
+                                  "end": 19,
+                                  "raw": "3",
+                                  "value": 51
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 22,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/((a)|(ab))((c)|(bc))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/((a)|(ab))((c)|(bc))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "((a)|(ab))((c)|(bc))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "((a)|(ab))((c)|(bc))",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "((a)|(ab))",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "(a)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 5,
+                          "raw": "(a)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 3,
+                              "end": 4,
+                              "raw": "a",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 3,
+                                  "end": 4,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": "(ab)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 10,
+                          "raw": "(ab)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 9,
+                              "raw": "ab",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 9,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 21,
+                  "raw": "((c)|(bc))",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 15,
+                      "raw": "(c)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 15,
+                          "raw": "(c)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 13,
+                              "end": 14,
+                              "raw": "c",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 20,
+                      "raw": "(bc)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 20,
+                          "raw": "(bc)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 17,
+                              "end": 19,
+                              "raw": "bc",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 17,
+                                  "end": 18,
+                                  "raw": "b",
+                                  "value": 98
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 18,
+                                  "end": 19,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 22,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/()/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/()/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "()",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "()",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "()",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 2,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/()|/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/()|/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "()|",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "()",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "()",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 2,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 4,
+              "end": 4,
+              "raw": "",
+              "elements": []
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.)(.)(.)(.)(.)(.)(.)(.)(.)\\9\\9/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/(.)(.)(.)(.)(.)(.)(.)(.)(.)\\9\\9/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "(.)(.)(.)(.)(.)(.)(.)(.)(.)\\9\\9",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "(.)(.)(.)(.)(.)(.)(.)(.)(.)\\9\\9",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 7,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 10,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 13,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 12,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 16,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 15,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 19,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 17,
+                      "end": 18,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 22,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 20,
+                      "end": 21,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 21,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 25,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 23,
+                      "end": 24,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 23,
+                          "end": 24,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 28,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 26,
+                      "end": 27,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 26,
+                          "end": 27,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../9",
+                    "♻️../10"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 30,
+                  "raw": "\\9",
+                  "ref": 9,
+                  "ambiguous": false,
+                  "resolved": "♻️../8"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 32,
+                  "raw": "\\9",
+                  "ref": 9,
+                  "ambiguous": false,
+                  "resolved": "♻️../8"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 33,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.)(.)(.)(.)(.)(.)(.)(.)\\8\\8/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/(.)(.)(.)(.)(.)(.)(.)(.)\\8\\8/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "(.)(.)(.)(.)(.)(.)(.)(.)\\8\\8",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "(.)(.)(.)(.)(.)(.)(.)(.)\\8\\8",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 7,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 10,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 13,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 12,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 16,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 15,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 19,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 17,
+                      "end": 18,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 22,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 20,
+                      "end": 21,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 21,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 25,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 23,
+                      "end": 24,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 23,
+                          "end": 24,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../8",
+                    "♻️../9"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 27,
+                  "raw": "\\8",
+                  "ref": 8,
+                  "ambiguous": false,
+                  "resolved": "♻️../7"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 29,
+                  "raw": "\\8",
+                  "ref": 8,
+                  "ambiguous": false,
+                  "resolved": "♻️../7"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 30,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.)..|abc/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(.)..|abc/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(.)..|abc",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(.)..",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 7,
+              "end": 10,
+              "raw": "abc",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.)\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/(.)\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "(.)\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(.)\\1",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 6,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.*?)a(?!(a+)b\\2c)\\2(.*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/(.*?)a(?!(a+)b\\2c)\\2(.*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "(.*?)a(?!(a+)b\\2c)\\2(.*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "(.*?)a(?!(a+)b\\2c)\\2(.*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "(.*?)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": ".*?",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 5,
+                          "raw": ".*?",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": false,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 19,
+                  "raw": "(?!(a+)b\\2c)",
+                  "kind": "lookahead",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 18,
+                      "raw": "(a+)b\\2c",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 14,
+                          "raw": "(a+)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 13,
+                              "raw": "a+",
+                              "elements": [
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 13,
+                                  "raw": "a+",
+                                  "min": 1,
+                                  "max": "$$Infinity",
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "Character",
+                                    "parent": "♻️..",
+                                    "start": 11,
+                                    "end": 12,
+                                    "raw": "a",
+                                    "value": 97
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../2",
+                            "♻️../../../../../3"
+                          ]
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 17,
+                          "raw": "\\2",
+                          "ref": 2,
+                          "ambiguous": false,
+                          "resolved": "♻️../0"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 21,
+                  "raw": "\\2",
+                  "ref": 2,
+                  "ambiguous": false,
+                  "resolved": "♻️../2/alternatives/0/elements/0"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 25,
+                  "raw": "(.*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 22,
+                      "end": 24,
+                      "raw": ".*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 24,
+                          "raw": ".*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 22,
+                            "end": 23,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 26,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.+).*\\1/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(.+).*\\1/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(.+).*\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(.+).*\\1",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(.+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": ".+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": ".+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 7,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 5,
+                    "end": 6,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 9,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(...)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/(...)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "(...)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(...)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "(...)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "...",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.{2}).+\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(.{2}).+\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(.{2}).+\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(.{2}).+\\1",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(.{2})",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": ".{2}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 6,
+                          "raw": ".{2}",
+                          "min": 2,
+                          "max": 2,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 9,
+                  "raw": ".+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 7,
+                    "end": 8,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.{3})(.{4})/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(.{3})(.{4})/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(.{3})(.{4})",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(.{3})(.{4})",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(.{3})",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": ".{3}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 6,
+                          "raw": ".{3}",
+                          "min": 3,
+                          "max": 3,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 13,
+                  "raw": "(.{4})",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 12,
+                      "raw": ".{4}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 12,
+                          "raw": ".{4}",
+                          "min": 4,
+                          "max": 4,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(123){1,}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(123){1,}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(123){1,}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(123){1,}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(123){1,}",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 6,
+                    "raw": "(123)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 5,
+                        "raw": "123",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": "1",
+                            "value": 49
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 3,
+                            "end": 4,
+                            "raw": "2",
+                            "value": 50
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 5,
+                            "raw": "3",
+                            "value": 51
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(123){1,}x\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(123){1,}x\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(123){1,}x\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(123){1,}x\\1",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(123){1,}",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 6,
+                    "raw": "(123)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 5,
+                        "raw": "123",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": "1",
+                            "value": 49
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 3,
+                            "end": 4,
+                            "raw": "2",
+                            "value": 50
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 5,
+                            "raw": "3",
+                            "value": 51
+                          }
+                        ]
+                      }
+                    ],
+                    "references": [
+                      "♻️../../2"
+                    ]
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "x",
+                  "value": 120
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 13,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/element"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?!a|b)|c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?!a|b)|c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?!a|b)|c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?!a|b)",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?!a|b)",
+                  "kind": "lookahead",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 9,
+              "end": 10,
+              "raw": "c",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?:ab|cd)+|ef/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(?:ab|cd)+|ef/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?:ab|cd)+|ef",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?:ab|cd)+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?:ab|cd)+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Group",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 10,
+                    "raw": "(?:ab|cd)",
+                    "modifiers": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 6,
+                        "raw": "ab",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 5,
+                            "raw": "a",
+                            "value": 97
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "b",
+                            "value": 98
+                          }
+                        ]
+                      },
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 7,
+                        "end": 9,
+                        "raw": "cd",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 7,
+                            "end": 8,
+                            "raw": "c",
+                            "value": 99
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "d",
+                            "value": 100
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 12,
+              "end": 14,
+              "raw": "ef",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?:ab|cd)\\d?/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?:ab|cd)\\d?/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?:ab|cd)\\d?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?:ab|cd)\\d?",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?:ab|cd)",
+                  "modifiers": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "ab",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 9,
+                      "raw": "cd",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "c",
+                          "value": 99
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "d",
+                          "value": 100
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 13,
+                  "raw": "\\d?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 10,
+                    "end": 12,
+                    "raw": "\\d",
+                    "kind": "digit",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?=(a+))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?=(a+))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?=(a+))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?=(a+))",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?=(a+))",
+                  "kind": "lookahead",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 8,
+                      "raw": "(a+)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 8,
+                          "raw": "(a+)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 5,
+                              "end": 7,
+                              "raw": "a+",
+                              "elements": [
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 5,
+                                  "end": 7,
+                                  "raw": "a+",
+                                  "min": 1,
+                                  "max": "$$Infinity",
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "Character",
+                                    "parent": "♻️..",
+                                    "start": 5,
+                                    "end": 6,
+                                    "raw": "a",
+                                    "value": 97
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?=(a+))a*b\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?=(a+))a*b\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?=(a+))a*b\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?=(a+))a*b\\1",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?=(a+))",
+                  "kind": "lookahead",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 8,
+                      "raw": "(a+)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 8,
+                          "raw": "(a+)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 5,
+                              "end": 7,
+                              "raw": "a+",
+                              "elements": [
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 5,
+                                  "end": 7,
+                                  "raw": "a+",
+                                  "min": 1,
+                                  "max": "$$Infinity",
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "Character",
+                                    "parent": "♻️..",
+                                    "start": 5,
+                                    "end": 6,
+                                    "raw": "a",
+                                    "value": 97
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../3"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "a*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 9,
+                    "end": 10,
+                    "raw": "a",
+                    "value": 97
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 14,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(A)?(A.*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(A)?(A.*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(A)?(A.*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(A)?(A.*)",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(A)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 4,
+                    "raw": "(A)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "A",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": "A",
+                            "value": 65
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 10,
+                  "raw": "(A.*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "A.*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "A",
+                          "value": 65
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 9,
+                          "raw": ".*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 7,
+                            "end": 8,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(A)\\1(B)\\2/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(A)\\1(B)\\2/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(A)\\1(B)\\2",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(A)\\1(B)\\2",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(A)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "A",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "A",
+                          "value": 65
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 6,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 9,
+                  "raw": "(B)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "B",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "B",
+                          "value": 66
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "\\2",
+                  "ref": 2,
+                  "ambiguous": false,
+                  "resolved": "♻️../2"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(A)\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/(A)\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "(A)\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(A)\\1",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(A)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "A",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "A",
+                          "value": 65
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 6,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(Rob)|(Bob)|(Robert)|(Bobby)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/(Rob)|(Bob)|(Robert)|(Bobby)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "(Rob)|(Bob)|(Robert)|(Bobby)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(Rob)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "(Rob)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "Rob",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "R",
+                          "value": 82
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 7,
+              "end": 12,
+              "raw": "(Bob)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 12,
+                  "raw": "(Bob)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 11,
+                      "raw": "Bob",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "B",
+                          "value": 66
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 13,
+              "end": 21,
+              "raw": "(Robert)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 21,
+                  "raw": "(Robert)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 20,
+                      "raw": "Robert",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": "R",
+                          "value": 82
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 16,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 17,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "r",
+                          "value": 114
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 20,
+                          "raw": "t",
+                          "value": 116
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 22,
+              "end": 29,
+              "raw": "(Bobby)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 29,
+                  "raw": "(Bobby)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 23,
+                      "end": 28,
+                      "raw": "Bobby",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 23,
+                          "end": 24,
+                          "raw": "B",
+                          "value": 66
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 24,
+                          "end": 25,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 25,
+                          "end": 26,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 26,
+                          "end": 27,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 27,
+                          "end": 28,
+                          "raw": "y",
+                          "value": 121
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 30,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/([Jj]ava([Ss]cript)?)\\sis\\s(fun\\w*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/([Jj]ava([Ss]cript)?)\\sis\\s(fun\\w*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "([Jj]ava([Ss]cript)?)\\sis\\s(fun\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "([Jj]ava([Ss]cript)?)\\sis\\s(fun\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 22,
+                  "raw": "([Jj]ava([Ss]cript)?)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 21,
+                      "raw": "[Jj]ava([Ss]cript)?",
+                      "elements": [
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 6,
+                          "raw": "[Jj]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 3,
+                              "end": 4,
+                              "raw": "J",
+                              "value": 74
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "j",
+                              "value": 106
+                            }
+                          ]
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "v",
+                          "value": 118
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 21,
+                          "raw": "([Ss]cript)?",
+                          "min": 0,
+                          "max": 1,
+                          "greedy": true,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 20,
+                            "raw": "([Ss]cript)",
+                            "name": null,
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 19,
+                                "raw": "[Ss]cript",
+                                "elements": [
+                                  {
+                                    "type": "CharacterClass",
+                                    "parent": "♻️../..",
+                                    "start": 10,
+                                    "end": 14,
+                                    "raw": "[Ss]",
+                                    "unicodeSets": false,
+                                    "negate": false,
+                                    "elements": [
+                                      {
+                                        "type": "Character",
+                                        "parent": "♻️../..",
+                                        "start": 11,
+                                        "end": 12,
+                                        "raw": "S",
+                                        "value": 83
+                                      },
+                                      {
+                                        "type": "Character",
+                                        "parent": "♻️../..",
+                                        "start": 12,
+                                        "end": 13,
+                                        "raw": "s",
+                                        "value": 115
+                                      }
+                                    ]
+                                  },
+                                  {
+                                    "type": "Character",
+                                    "parent": "♻️../..",
+                                    "start": 14,
+                                    "end": 15,
+                                    "raw": "c",
+                                    "value": 99
+                                  },
+                                  {
+                                    "type": "Character",
+                                    "parent": "♻️../..",
+                                    "start": 15,
+                                    "end": 16,
+                                    "raw": "r",
+                                    "value": 114
+                                  },
+                                  {
+                                    "type": "Character",
+                                    "parent": "♻️../..",
+                                    "start": 16,
+                                    "end": 17,
+                                    "raw": "i",
+                                    "value": 105
+                                  },
+                                  {
+                                    "type": "Character",
+                                    "parent": "♻️../..",
+                                    "start": 17,
+                                    "end": 18,
+                                    "raw": "p",
+                                    "value": 112
+                                  },
+                                  {
+                                    "type": "Character",
+                                    "parent": "♻️../..",
+                                    "start": 18,
+                                    "end": 19,
+                                    "raw": "t",
+                                    "value": 116
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 24,
+                  "raw": "\\s",
+                  "kind": "space",
+                  "negate": false
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "i",
+                  "value": 105
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "s",
+                  "value": 115
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 28,
+                  "raw": "\\s",
+                  "kind": "space",
+                  "negate": false
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 36,
+                  "raw": "(fun\\w*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 29,
+                      "end": 35,
+                      "raw": "fun\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 30,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 30,
+                          "end": 31,
+                          "raw": "u",
+                          "value": 117
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 31,
+                          "end": 32,
+                          "raw": "n",
+                          "value": 110
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 32,
+                          "end": 35,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 32,
+                            "end": 34,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 37,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/([Nn]?ever|([Nn]othing\\s{1,}))more/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/([Nn]?ever|([Nn]othing\\s{1,}))more/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "([Nn]?ever|([Nn]othing\\s{1,}))more",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "([Nn]?ever|([Nn]othing\\s{1,}))more",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 31,
+                  "raw": "([Nn]?ever|([Nn]othing\\s{1,}))",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 11,
+                      "raw": "[Nn]?ever",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 7,
+                          "raw": "[Nn]?",
+                          "min": 0,
+                          "max": 1,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 6,
+                            "raw": "[Nn]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 3,
+                                "end": 4,
+                                "raw": "N",
+                                "value": 78
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 4,
+                                "end": 5,
+                                "raw": "n",
+                                "value": 110
+                              }
+                            ]
+                          }
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "v",
+                          "value": 118
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "r",
+                          "value": 114
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 30,
+                      "raw": "([Nn]othing\\s{1,})",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 30,
+                          "raw": "([Nn]othing\\s{1,})",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 13,
+                              "end": 29,
+                              "raw": "[Nn]othing\\s{1,}",
+                              "elements": [
+                                {
+                                  "type": "CharacterClass",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 17,
+                                  "raw": "[Nn]",
+                                  "unicodeSets": false,
+                                  "negate": false,
+                                  "elements": [
+                                    {
+                                      "type": "Character",
+                                      "parent": "♻️../..",
+                                      "start": 14,
+                                      "end": 15,
+                                      "raw": "N",
+                                      "value": 78
+                                    },
+                                    {
+                                      "type": "Character",
+                                      "parent": "♻️../..",
+                                      "start": 15,
+                                      "end": 16,
+                                      "raw": "n",
+                                      "value": 110
+                                    }
+                                  ]
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 17,
+                                  "end": 18,
+                                  "raw": "o",
+                                  "value": 111
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 18,
+                                  "end": 19,
+                                  "raw": "t",
+                                  "value": 116
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 19,
+                                  "end": 20,
+                                  "raw": "h",
+                                  "value": 104
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 20,
+                                  "end": 21,
+                                  "raw": "i",
+                                  "value": 105
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 21,
+                                  "end": 22,
+                                  "raw": "n",
+                                  "value": 110
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 22,
+                                  "end": 23,
+                                  "raw": "g",
+                                  "value": 103
+                                },
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 23,
+                                  "end": 29,
+                                  "raw": "\\s{1,}",
+                                  "min": 1,
+                                  "max": "$$Infinity",
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️..",
+                                    "start": 23,
+                                    "end": 25,
+                                    "raw": "\\s",
+                                    "kind": "space",
+                                    "negate": false
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "m",
+                  "value": 109
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/([\\S]+([ \\t]+[\\S]+)*)[ \\t]*=[ \\t]*[\\S]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/([\\S]+([ \\t]+[\\S]+)*)[ \\t]*=[ \\t]*[\\S]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "([\\S]+([ \\t]+[\\S]+)*)[ \\t]*=[ \\t]*[\\S]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "([\\S]+([ \\t]+[\\S]+)*)[ \\t]*=[ \\t]*[\\S]+",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 22,
+                  "raw": "([\\S]+([ \\t]+[\\S]+)*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 21,
+                      "raw": "[\\S]+([ \\t]+[\\S]+)*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 7,
+                          "raw": "[\\S]+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 6,
+                            "raw": "[\\S]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterSet",
+                                "parent": "♻️../..",
+                                "start": 3,
+                                "end": 5,
+                                "raw": "\\S",
+                                "kind": "space",
+                                "negate": true
+                              }
+                            ]
+                          }
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 21,
+                          "raw": "([ \\t]+[\\S]+)*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 7,
+                            "end": 20,
+                            "raw": "([ \\t]+[\\S]+)",
+                            "name": null,
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 19,
+                                "raw": "[ \\t]+[\\S]+",
+                                "elements": [
+                                  {
+                                    "type": "Quantifier",
+                                    "parent": "♻️../..",
+                                    "start": 8,
+                                    "end": 14,
+                                    "raw": "[ \\t]+",
+                                    "min": 1,
+                                    "max": "$$Infinity",
+                                    "greedy": true,
+                                    "element": {
+                                      "type": "CharacterClass",
+                                      "parent": "♻️..",
+                                      "start": 8,
+                                      "end": 13,
+                                      "raw": "[ \\t]",
+                                      "unicodeSets": false,
+                                      "negate": false,
+                                      "elements": [
+                                        {
+                                          "type": "Character",
+                                          "parent": "♻️../..",
+                                          "start": 9,
+                                          "end": 10,
+                                          "raw": " ",
+                                          "value": 32
+                                        },
+                                        {
+                                          "type": "Character",
+                                          "parent": "♻️../..",
+                                          "start": 10,
+                                          "end": 12,
+                                          "raw": "\\t",
+                                          "value": 9
+                                        }
+                                      ]
+                                    }
+                                  },
+                                  {
+                                    "type": "Quantifier",
+                                    "parent": "♻️../..",
+                                    "start": 14,
+                                    "end": 19,
+                                    "raw": "[\\S]+",
+                                    "min": 1,
+                                    "max": "$$Infinity",
+                                    "greedy": true,
+                                    "element": {
+                                      "type": "CharacterClass",
+                                      "parent": "♻️..",
+                                      "start": 14,
+                                      "end": 18,
+                                      "raw": "[\\S]",
+                                      "unicodeSets": false,
+                                      "negate": false,
+                                      "elements": [
+                                        {
+                                          "type": "CharacterSet",
+                                          "parent": "♻️../..",
+                                          "start": 15,
+                                          "end": 17,
+                                          "raw": "\\S",
+                                          "kind": "space",
+                                          "negate": true
+                                        }
+                                      ]
+                                    }
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 28,
+                  "raw": "[ \\t]*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 22,
+                    "end": 27,
+                    "raw": "[ \\t]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 23,
+                        "end": 24,
+                        "raw": " ",
+                        "value": 32
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 24,
+                        "end": 26,
+                        "raw": "\\t",
+                        "value": 9
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "=",
+                  "value": 61
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 35,
+                  "raw": "[ \\t]*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 29,
+                    "end": 34,
+                    "raw": "[ \\t]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 30,
+                        "end": 31,
+                        "raw": " ",
+                        "value": 32
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 31,
+                        "end": 33,
+                        "raw": "\\t",
+                        "value": 9
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 40,
+                  "raw": "[\\S]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 35,
+                    "end": 39,
+                    "raw": "[\\S]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 36,
+                        "end": 38,
+                        "raw": "\\S",
+                        "kind": "space",
+                        "negate": true
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 41,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/([xu]\\d{2}([A-H]{2})?)\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/([xu]\\d{2}([A-H]{2})?)\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "([xu]\\d{2}([A-H]{2})?)\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "([xu]\\d{2}([A-H]{2})?)\\1",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 23,
+                  "raw": "([xu]\\d{2}([A-H]{2})?)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 22,
+                      "raw": "[xu]\\d{2}([A-H]{2})?",
+                      "elements": [
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 6,
+                          "raw": "[xu]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 3,
+                              "end": 4,
+                              "raw": "x",
+                              "value": 120
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "u",
+                              "value": 117
+                            }
+                          ]
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 11,
+                          "raw": "\\d{2}",
+                          "min": 2,
+                          "max": 2,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 8,
+                            "raw": "\\d",
+                            "kind": "digit",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 22,
+                          "raw": "([A-H]{2})?",
+                          "min": 0,
+                          "max": 1,
+                          "greedy": true,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 11,
+                            "end": 21,
+                            "raw": "([A-H]{2})",
+                            "name": null,
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 20,
+                                "raw": "[A-H]{2}",
+                                "elements": [
+                                  {
+                                    "type": "Quantifier",
+                                    "parent": "♻️../..",
+                                    "start": 12,
+                                    "end": 20,
+                                    "raw": "[A-H]{2}",
+                                    "min": 2,
+                                    "max": 2,
+                                    "greedy": true,
+                                    "element": {
+                                      "type": "CharacterClass",
+                                      "parent": "♻️..",
+                                      "start": 12,
+                                      "end": 17,
+                                      "raw": "[A-H]",
+                                      "unicodeSets": false,
+                                      "negate": false,
+                                      "elements": [
+                                        {
+                                          "type": "CharacterClassRange",
+                                          "parent": "♻️../..",
+                                          "start": 13,
+                                          "end": 16,
+                                          "raw": "A-H",
+                                          "min": {
+                                            "type": "Character",
+                                            "parent": "♻️..",
+                                            "start": 13,
+                                            "end": 14,
+                                            "raw": "A",
+                                            "value": 65
+                                          },
+                                          "max": {
+                                            "type": "Character",
+                                            "parent": "♻️..",
+                                            "start": 15,
+                                            "end": 16,
+                                            "raw": "H",
+                                            "value": 72
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 25,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 26,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\.(?!com|org)|\\/)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(\\.(?!com|org)|\\/)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(\\.(?!com|org)|\\/)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(\\.(?!com|org)|\\/)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 19,
+                  "raw": "(\\.(?!com|org)|\\/)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 15,
+                      "raw": "\\.(?!com|org)",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "\\.",
+                          "value": 46
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 15,
+                          "raw": "(?!com|org)",
+                          "kind": "lookahead",
+                          "negate": true,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 10,
+                              "raw": "com",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "c",
+                                  "value": 99
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 9,
+                                  "raw": "o",
+                                  "value": 111
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "m",
+                                  "value": 109
+                                }
+                              ]
+                            },
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 14,
+                              "raw": "org",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "o",
+                                  "value": 111
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": "r",
+                                  "value": 114
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "g",
+                                  "value": 103
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 18,
+                      "raw": "\\/",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 18,
+                          "raw": "\\/",
+                          "value": 47
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 20,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\d*)(\\d+)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(\\d*)(\\d+)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(\\d*)(\\d+)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(\\d*)(\\d+)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "(\\d*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "\\d*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 5,
+                          "raw": "\\d*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 4,
+                            "raw": "\\d",
+                            "kind": "digit",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 11,
+                  "raw": "(\\d+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 10,
+                      "raw": "\\d+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 10,
+                          "raw": "\\d+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 7,
+                            "end": 9,
+                            "raw": "\\d",
+                            "kind": "digit",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\d*)\\d(\\d+)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(\\d*)\\d(\\d+)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(\\d*)\\d(\\d+)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(\\d*)\\d(\\d+)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "(\\d*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "\\d*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 5,
+                          "raw": "\\d*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 4,
+                            "raw": "\\d",
+                            "kind": "digit",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 8,
+                  "raw": "\\d",
+                  "kind": "digit",
+                  "negate": false
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 13,
+                  "raw": "(\\d+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 12,
+                      "raw": "\\d+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 12,
+                          "raw": "\\d+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 11,
+                            "raw": "\\d",
+                            "kind": "digit",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\d+)/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(\\d+)/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "(\\d+)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(\\d+)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "(\\d+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "\\d+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 5,
+                          "raw": "\\d+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 4,
+                            "raw": "\\d",
+                            "kind": "digit",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\d{3})(\\d{3})\\1\\2/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(\\d{3})(\\d{3})\\1\\2/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(\\d{3})(\\d{3})\\1\\2",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(\\d{3})(\\d{3})\\1\\2",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(\\d{3})",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 7,
+                      "raw": "\\d{3}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 7,
+                          "raw": "\\d{3}",
+                          "min": 3,
+                          "max": 3,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 4,
+                            "raw": "\\d",
+                            "kind": "digit",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 15,
+                  "raw": "(\\d{3})",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 14,
+                      "raw": "\\d{3}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 14,
+                          "raw": "\\d{3}",
+                          "min": 3,
+                          "max": 3,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 11,
+                            "raw": "\\d",
+                            "kind": "digit",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 17,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 19,
+                  "raw": "\\2",
+                  "ref": 2,
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 20,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\|)([\\w\\x81-\\xff ]*)(\\|)([\\/a-z][\\w:\\/\\.]*\\.[a-z]{3,4})(\\|)/ig": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 64,
+        "raw": "/(\\|)([\\w\\x81-\\xff ]*)(\\|)([\\/a-z][\\w:\\/\\.]*\\.[a-z]{3,4})(\\|)/ig",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 61,
+          "raw": "(\\|)([\\w\\x81-\\xff ]*)(\\|)([\\/a-z][\\w:\\/\\.]*\\.[a-z]{3,4})(\\|)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 61,
+              "raw": "(\\|)([\\w\\x81-\\xff ]*)(\\|)([\\/a-z][\\w:\\/\\.]*\\.[a-z]{3,4})(\\|)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(\\|)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "\\|",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "\\|",
+                          "value": 124
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 22,
+                  "raw": "([\\w\\x81-\\xff ]*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 21,
+                      "raw": "[\\w\\x81-\\xff ]*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 21,
+                          "raw": "[\\w\\x81-\\xff ]*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 20,
+                            "raw": "[\\w\\x81-\\xff ]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterSet",
+                                "parent": "♻️../..",
+                                "start": 7,
+                                "end": 9,
+                                "raw": "\\w",
+                                "kind": "word",
+                                "negate": false
+                              },
+                              {
+                                "type": "CharacterClassRange",
+                                "parent": "♻️../..",
+                                "start": 9,
+                                "end": 18,
+                                "raw": "\\x81-\\xff",
+                                "min": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 9,
+                                  "end": 13,
+                                  "raw": "\\x81",
+                                  "value": 129
+                                },
+                                "max": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 14,
+                                  "end": 18,
+                                  "raw": "\\xff",
+                                  "value": 255
+                                }
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 18,
+                                "end": 19,
+                                "raw": " ",
+                                "value": 32
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 26,
+                  "raw": "(\\|)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 23,
+                      "end": 25,
+                      "raw": "\\|",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 23,
+                          "end": 25,
+                          "raw": "\\|",
+                          "value": 124
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 57,
+                  "raw": "([\\/a-z][\\w:\\/\\.]*\\.[a-z]{3,4})",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 27,
+                      "end": 56,
+                      "raw": "[\\/a-z][\\w:\\/\\.]*\\.[a-z]{3,4}",
+                      "elements": [
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 27,
+                          "end": 34,
+                          "raw": "[\\/a-z]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 28,
+                              "end": 30,
+                              "raw": "\\/",
+                              "value": 47
+                            },
+                            {
+                              "type": "CharacterClassRange",
+                              "parent": "♻️../..",
+                              "start": 30,
+                              "end": 33,
+                              "raw": "a-z",
+                              "min": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 30,
+                                "end": 31,
+                                "raw": "a",
+                                "value": 97
+                              },
+                              "max": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 32,
+                                "end": 33,
+                                "raw": "z",
+                                "value": 122
+                              }
+                            }
+                          ]
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 34,
+                          "end": 44,
+                          "raw": "[\\w:\\/\\.]*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 34,
+                            "end": 43,
+                            "raw": "[\\w:\\/\\.]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterSet",
+                                "parent": "♻️../..",
+                                "start": 35,
+                                "end": 37,
+                                "raw": "\\w",
+                                "kind": "word",
+                                "negate": false
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 37,
+                                "end": 38,
+                                "raw": ":",
+                                "value": 58
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 38,
+                                "end": 40,
+                                "raw": "\\/",
+                                "value": 47
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 40,
+                                "end": 42,
+                                "raw": "\\.",
+                                "value": 46
+                              }
+                            ]
+                          }
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 44,
+                          "end": 46,
+                          "raw": "\\.",
+                          "value": 46
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 46,
+                          "end": 56,
+                          "raw": "[a-z]{3,4}",
+                          "min": 3,
+                          "max": 4,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 46,
+                            "end": 51,
+                            "raw": "[a-z]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterClassRange",
+                                "parent": "♻️../..",
+                                "start": 47,
+                                "end": 50,
+                                "raw": "a-z",
+                                "min": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 47,
+                                  "end": 48,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                "max": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 49,
+                                  "end": 50,
+                                  "raw": "z",
+                                  "value": 122
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 57,
+                  "end": 61,
+                  "raw": "(\\|)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 58,
+                      "end": 60,
+                      "raw": "\\|",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 58,
+                          "end": 60,
+                          "raw": "\\|",
+                          "value": 124
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 62,
+          "end": 64,
+          "raw": "ig",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(a(b(c)))(d(e(f)))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(a(b(c)))(d(e(f)))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(a(b(c)))(d(e(f)))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(a(b(c)))(d(e(f)))",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(a(b(c)))",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 9,
+                      "raw": "a(b(c))",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 9,
+                          "raw": "(b(c))",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 4,
+                              "end": 8,
+                              "raw": "b(c)",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 4,
+                                  "end": 5,
+                                  "raw": "b",
+                                  "value": 98
+                                },
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 5,
+                                  "end": 8,
+                                  "raw": "(c)",
+                                  "name": null,
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 6,
+                                      "end": 7,
+                                      "raw": "c",
+                                      "elements": [
+                                        {
+                                          "type": "Character",
+                                          "parent": "♻️../..",
+                                          "start": 6,
+                                          "end": 7,
+                                          "raw": "c",
+                                          "value": 99
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": []
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 19,
+                  "raw": "(d(e(f)))",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 18,
+                      "raw": "d(e(f))",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 18,
+                          "raw": "(e(f))",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 13,
+                              "end": 17,
+                              "raw": "e(f)",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "e",
+                                  "value": 101
+                                },
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 14,
+                                  "end": 17,
+                                  "raw": "(f)",
+                                  "name": null,
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 15,
+                                      "end": 16,
+                                      "raw": "f",
+                                      "elements": [
+                                        {
+                                          "type": "Character",
+                                          "parent": "♻️../..",
+                                          "start": 15,
+                                          "end": 16,
+                                          "raw": "f",
+                                          "value": 102
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": []
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 20,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(a(b(c)))(d(e(f)))\\2\\5/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/(a(b(c)))(d(e(f)))\\2\\5/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "(a(b(c)))(d(e(f)))\\2\\5",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "(a(b(c)))(d(e(f)))\\2\\5",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(a(b(c)))",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 9,
+                      "raw": "a(b(c))",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 9,
+                          "raw": "(b(c))",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 4,
+                              "end": 8,
+                              "raw": "b(c)",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 4,
+                                  "end": 5,
+                                  "raw": "b",
+                                  "value": 98
+                                },
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 5,
+                                  "end": 8,
+                                  "raw": "(c)",
+                                  "name": null,
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 6,
+                                      "end": 7,
+                                      "raw": "c",
+                                      "elements": [
+                                        {
+                                          "type": "Character",
+                                          "parent": "♻️../..",
+                                          "start": 6,
+                                          "end": 7,
+                                          "raw": "c",
+                                          "value": 99
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": []
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../2"
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 19,
+                  "raw": "(d(e(f)))",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 18,
+                      "raw": "d(e(f))",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 18,
+                          "raw": "(e(f))",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 13,
+                              "end": 17,
+                              "raw": "e(f)",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "e",
+                                  "value": 101
+                                },
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 14,
+                                  "end": 17,
+                                  "raw": "(f)",
+                                  "name": null,
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 15,
+                                      "end": 16,
+                                      "raw": "f",
+                                      "elements": [
+                                        {
+                                          "type": "Character",
+                                          "parent": "♻️../..",
+                                          "start": 15,
+                                          "end": 16,
+                                          "raw": "f",
+                                          "value": 102
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": []
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../3"
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 21,
+                  "raw": "\\2",
+                  "ref": 2,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/1"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 23,
+                  "raw": "\\5",
+                  "ref": 5,
+                  "ambiguous": false,
+                  "resolved": "♻️../1/alternatives/0/elements/1"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 24,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(a)?(a)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(a)?(a)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(a)?(a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(a)?(a)",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(a)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 4,
+                    "raw": "(a)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": "a",
+                            "value": 97
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 8,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(a)?a/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/(a)?a/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "(a)?a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(a)?a",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(a)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 4,
+                    "raw": "(a)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": "a",
+                            "value": 97
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(a*)b\\1+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(a*)b\\1+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(a*)b\\1+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(a*)b\\1+",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(a*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "a*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "a*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": "a",
+                            "value": 97
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2/element"
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 9,
+                  "raw": "\\1+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Backreference",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 8,
+                    "raw": "\\1",
+                    "ref": 1,
+                    "ambiguous": false,
+                    "resolved": "♻️../../0"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(aa).+\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(aa).+\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(aa).+\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(aa).+\\1",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(aa)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "aa",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 7,
+                  "raw": ".+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 5,
+                    "end": 6,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 9,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(aa)bcd\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(aa)bcd\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(aa)bcd\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(aa)bcd\\1",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(aa)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "aa",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../4"
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 10,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(aa|aabaac|ba|b|c)*/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(aa|aabaac|ba|b|c)*/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(aa|aabaac|ba|b|c)*",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(aa|aabaac|ba|b|c)*",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 20,
+                  "raw": "(aa|aabaac|ba|b|c)*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 19,
+                    "raw": "(aa|aabaac|ba|b|c)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 4,
+                        "raw": "aa",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": "a",
+                            "value": 97
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 3,
+                            "end": 4,
+                            "raw": "a",
+                            "value": 97
+                          }
+                        ]
+                      },
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 11,
+                        "raw": "aabaac",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "a",
+                            "value": 97
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "a",
+                            "value": 97
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 7,
+                            "end": 8,
+                            "raw": "b",
+                            "value": 98
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "a",
+                            "value": 97
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "a",
+                            "value": 97
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "c",
+                            "value": 99
+                          }
+                        ]
+                      },
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 12,
+                        "end": 14,
+                        "raw": "ba",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 13,
+                            "raw": "b",
+                            "value": 98
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 13,
+                            "end": 14,
+                            "raw": "a",
+                            "value": 97
+                          }
+                        ]
+                      },
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 15,
+                        "end": 16,
+                        "raw": "b",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 15,
+                            "end": 16,
+                            "raw": "b",
+                            "value": 98
+                          }
+                        ]
+                      },
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 17,
+                        "end": 18,
+                        "raw": "c",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 17,
+                            "end": 18,
+                            "raw": "c",
+                            "value": 99
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(abc)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/(abc)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "(abc)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(abc)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "(abc)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "abc",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(b+)(b*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(b+)(b*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(b+)(b*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(b+)(b*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(b+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "b+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "b+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": "b",
+                            "value": 98
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 9,
+                  "raw": "(b*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "b*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "b*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "b",
+                            "value": 98
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(b+)(b+)(b+)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(b+)(b+)(b+)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(b+)(b+)(b+)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(b+)(b+)(b+)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(b+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "b+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "b+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": "b",
+                            "value": 98
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 9,
+                  "raw": "(b+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "b+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "b+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "b",
+                            "value": 98
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 13,
+                  "raw": "(b+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 12,
+                      "raw": "b+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 12,
+                          "raw": "b+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "b",
+                            "value": 98
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(x)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/(x)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "(x)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "(x)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(x)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "x",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "x",
+                          "value": 120
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(x*)(x+)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(x*)(x+)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(x*)(x+)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(x*)(x+)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(x*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "x*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "x*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": "x",
+                            "value": 120
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 9,
+                  "raw": "(x+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "x+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "x+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "x",
+                            "value": 120
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(x+)(x*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(x+)(x*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(x+)(x*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(x+)(x*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(x+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "x+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "x+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 2,
+                            "end": 3,
+                            "raw": "x",
+                            "value": 120
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 9,
+                  "raw": "(x*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "x*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "x*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "x",
+                            "value": 120
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(z)((a+)?(b+)?(c))*/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(z)((a+)?(b+)?(c))*/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(z)((a+)?(b+)?(c))*",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(z)((a+)?(b+)?(c))*",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(z)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "z",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "z",
+                          "value": 122
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 20,
+                  "raw": "((a+)?(b+)?(c))*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 4,
+                    "end": 19,
+                    "raw": "((a+)?(b+)?(c))",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 18,
+                        "raw": "(a+)?(b+)?(c)",
+                        "elements": [
+                          {
+                            "type": "Quantifier",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 10,
+                            "raw": "(a+)?",
+                            "min": 0,
+                            "max": 1,
+                            "greedy": true,
+                            "element": {
+                              "type": "CapturingGroup",
+                              "parent": "♻️..",
+                              "start": 5,
+                              "end": 9,
+                              "raw": "(a+)",
+                              "name": null,
+                              "alternatives": [
+                                {
+                                  "type": "Alternative",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 8,
+                                  "raw": "a+",
+                                  "elements": [
+                                    {
+                                      "type": "Quantifier",
+                                      "parent": "♻️../..",
+                                      "start": 6,
+                                      "end": 8,
+                                      "raw": "a+",
+                                      "min": 1,
+                                      "max": "$$Infinity",
+                                      "greedy": true,
+                                      "element": {
+                                        "type": "Character",
+                                        "parent": "♻️..",
+                                        "start": 6,
+                                        "end": 7,
+                                        "raw": "a",
+                                        "value": 97
+                                      }
+                                    }
+                                  ]
+                                }
+                              ],
+                              "references": []
+                            }
+                          },
+                          {
+                            "type": "Quantifier",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 15,
+                            "raw": "(b+)?",
+                            "min": 0,
+                            "max": 1,
+                            "greedy": true,
+                            "element": {
+                              "type": "CapturingGroup",
+                              "parent": "♻️..",
+                              "start": 10,
+                              "end": 14,
+                              "raw": "(b+)",
+                              "name": null,
+                              "alternatives": [
+                                {
+                                  "type": "Alternative",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 13,
+                                  "raw": "b+",
+                                  "elements": [
+                                    {
+                                      "type": "Quantifier",
+                                      "parent": "♻️../..",
+                                      "start": 11,
+                                      "end": 13,
+                                      "raw": "b+",
+                                      "min": 1,
+                                      "max": "$$Infinity",
+                                      "greedy": true,
+                                      "element": {
+                                        "type": "Character",
+                                        "parent": "♻️..",
+                                        "start": 11,
+                                        "end": 12,
+                                        "raw": "b",
+                                        "value": 98
+                                      }
+                                    }
+                                  ]
+                                }
+                              ],
+                              "references": []
+                            }
+                          },
+                          {
+                            "type": "CapturingGroup",
+                            "parent": "♻️../..",
+                            "start": 15,
+                            "end": 18,
+                            "raw": "(c)",
+                            "name": null,
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 16,
+                                "end": 17,
+                                "raw": "c",
+                                "elements": [
+                                  {
+                                    "type": "Character",
+                                    "parent": "♻️../..",
+                                    "start": 16,
+                                    "end": 17,
+                                    "raw": "c",
+                                    "value": 99
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(|)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/(|)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "(|)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "(|)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(|)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 2,
+                      "raw": "",
+                      "elements": []
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/,/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 3,
+        "raw": "/,/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ",",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ",",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ",",
+                  "value": 44
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 3,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/,;/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/,;/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": ",;",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": ",;",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ",",
+                  "value": 44
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ";",
+                  "value": 59
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/,\\;/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/,\\;/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": ",\\;",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": ",\\;",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ",",
+                  "value": 44
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "\\;",
+                  "value": 59
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?!.)?/u": {
+      "error": {
+        "message": "Invalid regular expression: /.(?!.)?/u: Nothing to repeat",
+        "index": 8
+      }
+    },
+    "/.(?!.){2,3}/u": {
+      "error": {
+        "message": "Invalid regular expression: /.(?!.){2,3}/u: Nothing to repeat",
+        "index": 12
+      }
+    },
+    "/.(?<!.)?/": {
+      "error": {
+        "message": "Invalid regular expression: /.(?<!.)?/: Nothing to repeat",
+        "index": 9
+      }
+    },
+    "/.(?<!.)?/u": {
+      "error": {
+        "message": "Invalid regular expression: /.(?<!.)?/u: Nothing to repeat",
+        "index": 9
+      }
+    },
+    "/.(?<!.){2,3}/": {
+      "error": {
+        "message": "Invalid regular expression: /.(?<!.){2,3}/: Nothing to repeat",
+        "index": 13
+      }
+    },
+    "/.(?<!.){2,3}/u": {
+      "error": {
+        "message": "Invalid regular expression: /.(?<!.){2,3}/u: Nothing to repeat",
+        "index": 13
+      }
+    },
+    "/.(?<=.)?/": {
+      "error": {
+        "message": "Invalid regular expression: /.(?<=.)?/: Nothing to repeat",
+        "index": 9
+      }
+    },
+    "/.(?<=.)?/u": {
+      "error": {
+        "message": "Invalid regular expression: /.(?<=.)?/u: Nothing to repeat",
+        "index": 9
+      }
+    },
+    "/.(?<=.){2,3}/": {
+      "error": {
+        "message": "Invalid regular expression: /.(?<=.){2,3}/: Nothing to repeat",
+        "index": 13
+      }
+    },
+    "/.(?<=.){2,3}/u": {
+      "error": {
+        "message": "Invalid regular expression: /.(?<=.){2,3}/u: Nothing to repeat",
+        "index": 13
+      }
+    },
+    "/.(?=.)?/u": {
+      "error": {
+        "message": "Invalid regular expression: /.(?=.)?/u: Nothing to repeat",
+        "index": 8
+      }
+    },
+    "/.(?=.){2,3}/u": {
+      "error": {
+        "message": "Invalid regular expression: /.(?=.){2,3}/u: Nothing to repeat",
+        "index": 12
+      }
+    },
+    "/.(?=Z)*/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/.(?=Z)*/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": ".(?=Z)*",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": ".(?=Z)*",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "(?=Z)*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "(?=Z)",
+                    "kind": "lookahead",
+                    "negate": false,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?=Z)*?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/.(?=Z)*?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": ".(?=Z)*?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": ".(?=Z)*?",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "(?=Z)*?",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": false,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "(?=Z)",
+                    "kind": "lookahead",
+                    "negate": false,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?=Z)+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/.(?=Z)+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": ".(?=Z)+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": ".(?=Z)+",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "(?=Z)+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "(?=Z)",
+                    "kind": "lookahead",
+                    "negate": false,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?=Z)+?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/.(?=Z)+?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": ".(?=Z)+?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": ".(?=Z)+?",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "(?=Z)+?",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": false,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "(?=Z)",
+                    "kind": "lookahead",
+                    "negate": false,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?=Z)?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/.(?=Z)?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": ".(?=Z)?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": ".(?=Z)?",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "(?=Z)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "(?=Z)",
+                    "kind": "lookahead",
+                    "negate": false,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?=Z)??/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/.(?=Z)??/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": ".(?=Z)??",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": ".(?=Z)??",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "(?=Z)??",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": false,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "(?=Z)",
+                    "kind": "lookahead",
+                    "negate": false,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?=Z){2,3}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/.(?=Z){2,3}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": ".(?=Z){2,3}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": ".(?=Z){2,3}",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "(?=Z){2,3}",
+                  "min": 2,
+                  "max": 3,
+                  "greedy": true,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "(?=Z)",
+                    "kind": "lookahead",
+                    "negate": false,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?=Z){2,3}?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/.(?=Z){2,3}?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": ".(?=Z){2,3}?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": ".(?=Z){2,3}?",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "(?=Z){2,3}?",
+                  "min": 2,
+                  "max": 3,
+                  "greedy": false,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "(?=Z)",
+                    "kind": "lookahead",
+                    "negate": false,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?=Z){2,}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/.(?=Z){2,}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": ".(?=Z){2,}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": ".(?=Z){2,}",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "(?=Z){2,}",
+                  "min": 2,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "(?=Z)",
+                    "kind": "lookahead",
+                    "negate": false,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?=Z){2,}?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/.(?=Z){2,}?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": ".(?=Z){2,}?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": ".(?=Z){2,}?",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "(?=Z){2,}?",
+                  "min": 2,
+                  "max": "$$Infinity",
+                  "greedy": false,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "(?=Z)",
+                    "kind": "lookahead",
+                    "negate": false,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?=Z){2}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/.(?=Z){2}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": ".(?=Z){2}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": ".(?=Z){2}",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "(?=Z){2}",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "(?=Z)",
+                    "kind": "lookahead",
+                    "negate": false,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?=Z){2}?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/.(?=Z){2}?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": ".(?=Z){2}?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": ".(?=Z){2}?",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "(?=Z){2}?",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": false,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "(?=Z)",
+                    "kind": "lookahead",
+                    "negate": false,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.*/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/.*/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": ".*",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": ".*",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.*?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/.*?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": ".*?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": ".*?",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": ".*?",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": false,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.*a.*/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/.*a.*/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": ".*a.*",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": ".*a.*",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 6,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 4,
+                    "end": 5,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/.+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": ".+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": ".+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": ".+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.+: gr(a|e)y/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/.+: gr(a|e)y/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": ".+: gr(a|e)y",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": ".+: gr(a|e)y",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": ".+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": ":",
+                  "value": 58
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": " ",
+                  "value": 32
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "g",
+                  "value": 103
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 12,
+                  "raw": "(a|e)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 11,
+                      "raw": "e",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "e",
+                          "value": 101
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "y",
+                  "value": 121
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./iu": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./iu",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "iu",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./iug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/./iug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 6,
+          "raw": "iug",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./iy": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./iy",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "iy",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./ug": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./ug",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "ug",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./yg": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./yg",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "yg",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.?.?.?.?.?.?.?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/.?.?.?.?.?.?.?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": ".?.?.?.?.?.?.?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": ".?.?.?.?.?.?.?",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": ".?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": ".?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 7,
+                  "raw": ".?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 5,
+                    "end": 6,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 9,
+                  "raw": ".?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 7,
+                    "end": 8,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": ".?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 9,
+                    "end": 10,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 13,
+                  "raw": ".?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 11,
+                    "end": 12,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 15,
+                  "raw": ".?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 13,
+                    "end": 14,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/.?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": ".?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": ".?",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": ".?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.[\\b]./": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/.[\\b]./",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": ".[\\b].",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": ".[\\b].",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 6,
+                  "raw": "[\\b]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "\\b",
+                      "value": 8
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.{0,93}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/.{0,93}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": ".{0,93}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": ".{0,93}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": ".{0,93}",
+                  "min": 0,
+                  "max": 93,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.{1,2}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/.{1,2}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": ".{1,2}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": ".{1,2}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": ".{1,2}",
+                  "min": 1,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.{1,}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/.{1,}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": ".{1,}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": ".{1,}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": ".{1,}",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.{1}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/.{1}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": ".{1}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": ".{1}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": ".{1}",
+                  "min": 1,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/11111|111/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/11111|111/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "11111|111",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "11111",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "1",
+                  "value": 49
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "1",
+                  "value": 49
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "1",
+                  "value": 49
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "1",
+                  "value": 49
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "1",
+                  "value": 49
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 7,
+              "end": 10,
+              "raw": "111",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "1",
+                  "value": 49
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "1",
+                  "value": 49
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "1",
+                  "value": 49
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/1?1/mig": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/1?1/mig",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "1?1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "1?1",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "1?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "1",
+                    "value": 49
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "1",
+                  "value": 49
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 8,
+          "raw": "mig",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/1a/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/1a/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "1a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "1a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "1",
+                  "value": 49
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/1|12/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/1|12/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "1|12",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "1",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "1",
+                  "value": 49
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 3,
+              "end": 5,
+              "raw": "12",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "1",
+                  "value": 49
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "2",
+                  "value": 50
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/2|12/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/2|12/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "2|12",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "2",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "2",
+                  "value": 50
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 3,
+              "end": 5,
+              "raw": "12",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "1",
+                  "value": 49
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "2",
+                  "value": 50
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/7\\89/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/7\\89/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "7\\89",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "7\\89",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "7",
+                  "value": 55
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "\\8",
+                  "value": 56
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "9",
+                  "value": 57
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/8\\90/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/8\\90/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "8\\90",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "8\\90",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "8",
+                  "value": 56
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "\\9",
+                  "value": 57
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "0",
+                  "value": 48
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/;/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 3,
+        "raw": "/;/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ";",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ";",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ";",
+                  "value": 59
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 3,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/<body.*>((.*\\n?)*?)<\\/body>/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/<body.*>((.*\\n?)*?)<\\/body>/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "<body.*>((.*\\n?)*?)<\\/body>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "<body.*>((.*\\n?)*?)<\\/body>",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "<",
+                  "value": 60
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "y",
+                  "value": 121
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 8,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 7,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": ">",
+                  "value": 62
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 20,
+                  "raw": "((.*\\n?)*?)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 19,
+                      "raw": "(.*\\n?)*?",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 19,
+                          "raw": "(.*\\n?)*?",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": false,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 10,
+                            "end": 17,
+                            "raw": "(.*\\n?)",
+                            "name": null,
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 11,
+                                "end": 16,
+                                "raw": ".*\\n?",
+                                "elements": [
+                                  {
+                                    "type": "Quantifier",
+                                    "parent": "♻️../..",
+                                    "start": 11,
+                                    "end": 13,
+                                    "raw": ".*",
+                                    "min": 0,
+                                    "max": "$$Infinity",
+                                    "greedy": true,
+                                    "element": {
+                                      "type": "CharacterSet",
+                                      "parent": "♻️..",
+                                      "start": 11,
+                                      "end": 12,
+                                      "raw": ".",
+                                      "kind": "any"
+                                    }
+                                  },
+                                  {
+                                    "type": "Quantifier",
+                                    "parent": "♻️../..",
+                                    "start": 13,
+                                    "end": 16,
+                                    "raw": "\\n?",
+                                    "min": 0,
+                                    "max": 1,
+                                    "greedy": true,
+                                    "element": {
+                                      "type": "Character",
+                                      "parent": "♻️..",
+                                      "start": 13,
+                                      "end": 15,
+                                      "raw": "\\n",
+                                      "value": 10
+                                    }
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "<",
+                  "value": 60
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 23,
+                  "raw": "\\/",
+                  "value": 47
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "y",
+                  "value": 121
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": ">",
+                  "value": 62
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/AL|se/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/AL|se/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "AL|se",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "AL",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "A",
+                  "value": 65
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "L",
+                  "value": 76
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 4,
+              "end": 6,
+              "raw": "se",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "s",
+                  "value": 115
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/Java(?!Script)([A-Z]\\w*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/Java(?!Script)([A-Z]\\w*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "Java(?!Script)([A-Z]\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "Java(?!Script)([A-Z]\\w*)",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "J",
+                  "value": 74
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "v",
+                  "value": 118
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 15,
+                  "raw": "(?!Script)",
+                  "kind": "lookahead",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 14,
+                      "raw": "Script",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "S",
+                          "value": 83
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "c",
+                          "value": 99
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "r",
+                          "value": 114
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "i",
+                          "value": 105
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "p",
+                          "value": 112
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "t",
+                          "value": 116
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 25,
+                  "raw": "([A-Z]\\w*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 24,
+                      "raw": "[A-Z]\\w*",
+                      "elements": [
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 21,
+                          "raw": "[A-Z]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "CharacterClassRange",
+                              "parent": "♻️../..",
+                              "start": 17,
+                              "end": 20,
+                              "raw": "A-Z",
+                              "min": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 17,
+                                "end": 18,
+                                "raw": "A",
+                                "value": 65
+                              },
+                              "max": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 19,
+                                "end": 20,
+                                "raw": "Z",
+                                "value": 90
+                              }
+                            }
+                          ]
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 21,
+                          "end": 24,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 21,
+                            "end": 23,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 26,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/LS/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/LS/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "LS",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "LS",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "L",
+                  "value": 76
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "S",
+                  "value": 83
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/O\\PQ/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/O\\PQ/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "O\\PQ",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "O\\PQ",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "O",
+                  "value": 79
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "\\P",
+                  "value": 80
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "Q",
+                  "value": 81
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/X/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 3,
+        "raw": "/X/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "X",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "X",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "X",
+                  "value": 88
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 3,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\"'][^\"']*[\"']/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/[\"'][^\"']*[\"']/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "[\"'][^\"']*[\"']",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "[\"'][^\"']*[\"']",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[\"']",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "\"",
+                      "value": 34
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "'",
+                      "value": 39
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 11,
+                  "raw": "[^\"']*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 5,
+                    "end": 10,
+                    "raw": "[^\"']",
+                    "unicodeSets": false,
+                    "negate": true,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 7,
+                        "end": 8,
+                        "raw": "\"",
+                        "value": 34
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 8,
+                        "end": 9,
+                        "raw": "'",
+                        "value": 39
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 15,
+                  "raw": "[\"']",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 13,
+                      "raw": "\"",
+                      "value": 34
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 14,
+                      "raw": "'",
+                      "value": 39
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[%-\\d]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[%-\\d]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[%-\\d]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[%-\\d]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[%-\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 7,
+                    "raw": "[%-\\d]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "%",
+                        "value": 37
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "-",
+                        "value": 45
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 6,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[%-\\d]/u": {
+      "error": {
+        "message": "Invalid regular expression: /[%-\\d]/u: Invalid character class",
+        "index": 6
+      }
+    },
+    "/[%-\\dz]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[%-\\dz]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[%-\\dz]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[%-\\dz]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[%-\\dz]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 8,
+                    "raw": "[%-\\dz]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "%",
+                        "value": 37
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "-",
+                        "value": 45
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 6,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 6,
+                        "end": 7,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[*&$]{3}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[*&$]{3}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[*&$]{3}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[*&$]{3}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[*&$]{3}",
+                  "min": 3,
+                  "max": 3,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 6,
+                    "raw": "[*&$]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "*",
+                        "value": 42
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "&",
+                        "value": 38
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "$",
+                        "value": 36
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[--\\d]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[--\\d]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[--\\d]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[--\\d]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[--\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 7,
+                    "raw": "[--\\d]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "-",
+                        "value": 45
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "-",
+                        "value": 45
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 6,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[--\\d]/u": {
+      "error": {
+        "message": "Invalid regular expression: /[--\\d]/u: Invalid character class",
+        "index": 6
+      }
+    },
+    "/[--\\dz]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[--\\dz]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[--\\dz]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[--\\dz]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[--\\dz]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 8,
+                    "raw": "[--\\dz]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "-",
+                        "value": 45
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "-",
+                        "value": 45
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 6,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 6,
+                        "end": 7,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[.-.]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/[.-.]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "[.-.]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "[.-.]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[.-.]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": ".-.",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": ".",
+                        "value": 46
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": ".",
+                        "value": 46
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[//]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/[//]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "[//]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "[//]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[//]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "/",
+                      "value": 47
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "/",
+                      "value": 47
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[/]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/[/]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "[/]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "[/]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "[/]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "/",
+                      "value": 47
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[1234567].{2}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/[1234567].{2}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "[1234567].{2}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "[1234567].{2}",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "[1234567]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "1",
+                      "value": 49
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "2",
+                      "value": 50
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "3",
+                      "value": 51
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "4",
+                      "value": 52
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "5",
+                      "value": 53
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "6",
+                      "value": 54
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "7",
+                      "value": 55
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 14,
+                  "raw": ".{2}",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 10,
+                    "end": 11,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[Jj]ava([Ss]cript)?(?=\\:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/[Jj]ava([Ss]cript)?(?=\\:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "[Jj]ava([Ss]cript)?(?=\\:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "[Jj]ava([Ss]cript)?(?=\\:)",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[Jj]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "J",
+                      "value": 74
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "j",
+                      "value": 106
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "v",
+                  "value": 118
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 20,
+                  "raw": "([Ss]cript)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 8,
+                    "end": 19,
+                    "raw": "([Ss]cript)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 18,
+                        "raw": "[Ss]cript",
+                        "elements": [
+                          {
+                            "type": "CharacterClass",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 13,
+                            "raw": "[Ss]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "S",
+                                "value": 83
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 11,
+                                "end": 12,
+                                "raw": "s",
+                                "value": 115
+                              }
+                            ]
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 13,
+                            "end": 14,
+                            "raw": "c",
+                            "value": 99
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 14,
+                            "end": 15,
+                            "raw": "r",
+                            "value": 114
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 15,
+                            "end": 16,
+                            "raw": "i",
+                            "value": 105
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 16,
+                            "end": 17,
+                            "raw": "p",
+                            "value": 112
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 17,
+                            "end": 18,
+                            "raw": "t",
+                            "value": 116
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 26,
+                  "raw": "(?=\\:)",
+                  "kind": "lookahead",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 23,
+                      "end": 25,
+                      "raw": "\\:",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 23,
+                          "end": 25,
+                          "raw": "\\:",
+                          "value": 58
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 27,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[Nn]?evermore/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/[Nn]?evermore/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "[Nn]?evermore",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "[Nn]?evermore",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[Nn]?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 5,
+                    "raw": "[Nn]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "N",
+                        "value": 78
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "n",
+                        "value": 110
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "v",
+                  "value": 118
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "m",
+                  "value": 109
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[Nn]evermore/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/[Nn]evermore/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "[Nn]evermore",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "[Nn]evermore",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[Nn]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "N",
+                      "value": 78
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "n",
+                      "value": 110
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "v",
+                  "value": 118
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "m",
+                  "value": 109
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\*]/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/[\\*]/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "[\\*]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "[\\*]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[\\*]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "\\*",
+                      "value": 42
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 7,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\\\]/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/[\\\\]/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "[\\\\]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "[\\\\]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[\\\\]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "\\\\",
+                      "value": 92
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 7,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\\\c-f]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[\\\\c-f]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[\\\\c-f]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[\\\\c-f]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[\\\\c-f]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "\\\\",
+                      "value": 92
+                    },
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "c-f",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "c",
+                        "value": 99
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 7,
+                        "raw": "f",
+                        "value": 102
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\b-A]/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[\\b-A]/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "[\\b-A]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "[\\b-A]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "[\\b-A]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "\\b-A",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 4,
+                        "raw": "\\b",
+                        "value": 8
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "A",
+                        "value": 65
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\b]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/[\\b]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "[\\b]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "[\\b]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[\\b]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "\\b",
+                      "value": 8
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\b]/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/[\\b]/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "[\\b]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "[\\b]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[\\b]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "\\b",
+                      "value": 8
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 7,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\c00]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[\\c00]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[\\c00]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[\\c00]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[\\c00]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 7,
+                    "raw": "[\\c00]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 5,
+                        "raw": "\\c0",
+                        "value": 16
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "0",
+                        "value": 48
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\c0]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/[\\c0]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "[\\c0]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "[\\c0]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[\\c0]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "\\c0",
+                      "value": 16
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\c10]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[\\c10]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[\\c10]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[\\c10]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[\\c10]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 7,
+                    "raw": "[\\c10]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 5,
+                        "raw": "\\c1",
+                        "value": 17
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "0",
+                        "value": 48
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\c80]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[\\c80]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[\\c80]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[\\c80]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[\\c80]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 7,
+                    "raw": "[\\c80]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 5,
+                        "raw": "\\c8",
+                        "value": 24
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "0",
+                        "value": 48
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\c8]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/[\\c8]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "[\\c8]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "[\\c8]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[\\c8]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "\\c8",
+                      "value": 24
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\c90]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[\\c90]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[\\c90]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[\\c90]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[\\c90]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 7,
+                    "raw": "[\\c90]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 5,
+                        "raw": "\\c9",
+                        "value": 25
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "0",
+                        "value": 48
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\c9]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/[\\c9]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "[\\c9]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "[\\c9]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[\\c9]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "\\c9",
+                      "value": 25
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\d-a]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[\\d-a]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[\\d-a]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[\\d-a]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[\\d-a]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 7,
+                    "raw": "[\\d-a]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 4,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "-",
+                        "value": 45
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "a",
+                        "value": 97
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\d-a]/u": {
+      "error": {
+        "message": "Invalid regular expression: /[\\d-a]/u: Invalid character class",
+        "index": 6
+      }
+    },
+    "/[\\d-az]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[\\d-az]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[\\d-az]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[\\d-az]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[\\d-az]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 8,
+                    "raw": "[\\d-az]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 4,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "-",
+                        "value": 45
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 6,
+                        "end": 7,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\d]*[\\s]*bc./": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/[\\d]*[\\s]*bc./",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "[\\d]*[\\s]*bc.",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "[\\d]*[\\s]*bc.",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[\\d]*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 5,
+                    "raw": "[\\d]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 4,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 11,
+                  "raw": "[\\s]*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 10,
+                    "raw": "[\\s]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 7,
+                        "end": 9,
+                        "raw": "\\s",
+                        "kind": "space",
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\d][\\n][^\\d]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/[\\d][\\n][^\\d]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "[\\d][\\n][^\\d]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "[\\d][\\n][^\\d]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[\\d]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterSet",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "\\d",
+                      "kind": "digit",
+                      "negate": false
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 9,
+                  "raw": "[\\n]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "\\n",
+                      "value": 10
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 14,
+                  "raw": "[^\\d]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "CharacterSet",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 13,
+                      "raw": "\\d",
+                      "kind": "digit",
+                      "negate": false
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\s-\\d]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[\\s-\\d]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[\\s-\\d]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[\\s-\\d]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[\\s-\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 8,
+                    "raw": "[\\s-\\d]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 4,
+                        "raw": "\\s",
+                        "kind": "space",
+                        "negate": false
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "-",
+                        "value": 45
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 7,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\s-\\d]/u": {
+      "error": {
+        "message": "Invalid regular expression: /[\\s-\\d]/u: Invalid character class",
+        "index": 7
+      }
+    },
+    "/[\\s-\\dz]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/[\\s-\\dz]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "[\\s-\\dz]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "[\\s-\\dz]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "[\\s-\\dz]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 9,
+                    "raw": "[\\s-\\dz]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 4,
+                        "raw": "\\s",
+                        "kind": "space",
+                        "negate": false
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "-",
+                        "value": 45
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 7,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 7,
+                        "end": 8,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\u0390]/ui": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/[\\u0390]/ui",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[\\u0390]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[\\u0390]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[\\u0390]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "\\u0390",
+                      "value": 912
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 12,
+          "raw": "ui",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\u03b0]/ui": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/[\\u03b0]/ui",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[\\u03b0]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[\\u03b0]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[\\u03b0]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "\\u03b0",
+                      "value": 944
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 12,
+          "raw": "ui",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\u1fd3]/ui": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/[\\u1fd3]/ui",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[\\u1fd3]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[\\u1fd3]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[\\u1fd3]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "\\u1fd3",
+                      "value": 8147
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 12,
+          "raw": "ui",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\u1fe3]/ui": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/[\\u1fe3]/ui",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[\\u1fe3]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[\\u1fe3]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[\\u1fe3]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "\\u1fe3",
+                      "value": 8163
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 12,
+          "raw": "ui",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\ud800\\udc00]/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/[\\ud800\\udc00]/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "[\\ud800\\udc00]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "[\\ud800\\udc00]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "[\\ud800\\udc00]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 14,
+                      "raw": "\\ud800\\udc00",
+                      "value": 65536
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\ufb05]/ui": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/[\\ufb05]/ui",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[\\ufb05]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[\\ufb05]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[\\ufb05]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "\\ufb05",
+                      "value": 64261
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 12,
+          "raw": "ui",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\ufb06]/ui": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/[\\ufb06]/ui",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[\\ufb06]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[\\ufb06]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[\\ufb06]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "\\ufb06",
+                      "value": 64262
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 12,
+          "raw": "ui",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[]a/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/[]a/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "[]a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "[]a",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "[]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[^\"]*/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/[^\"]*/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "[^\"]*",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "[^\"]*",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[^\"]*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 5,
+                    "raw": "[^\"]",
+                    "unicodeSets": false,
+                    "negate": true,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "\"",
+                        "value": 34
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[^\\[\\b\\]]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/[^\\[\\b\\]]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "[^\\[\\b\\]]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "[^\\[\\b\\]]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "[^\\[\\b\\]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 10,
+                    "raw": "[^\\[\\b\\]]",
+                    "unicodeSets": false,
+                    "negate": true,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\[",
+                        "value": 91
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 7,
+                        "raw": "\\b",
+                        "value": 8
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 7,
+                        "end": 9,
+                        "raw": "\\]",
+                        "value": 93
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[^\\b]+/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[^\\b]+/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "[^\\b]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "[^\\b]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "[^\\b]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 6,
+                    "raw": "[^\\b]",
+                    "unicodeSets": false,
+                    "negate": true,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\b",
+                        "value": 8
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[^]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/[^]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "[^]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "[^]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "[^]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[^]a/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/[^]a/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "[^]a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "[^]a",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "[^]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 7,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[^a-z]{4}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/[^a-z]{4}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "[^a-z]{4}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "[^a-z]{4}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "[^a-z]{4}",
+                  "min": 4,
+                  "max": 4,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 7,
+                    "raw": "[^a-z]",
+                    "unicodeSets": false,
+                    "negate": true,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 6,
+                        "raw": "a-z",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "z",
+                          "value": 122
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[^a]*/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/[^a]*/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "[^a]*",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "[^a]*",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[^a]*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 5,
+                    "raw": "[^a]",
+                    "unicodeSets": false,
+                    "negate": true,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "a",
+                        "value": 97
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[^e]$/mg": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[^e]$/mg",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "[^e]$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "[^e]$",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[^e]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "e",
+                      "value": 101
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 9,
+          "raw": "mg",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[^o]t\\b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[^o]t\\b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[^o]t\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[^o]t\\b",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[^o]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "o",
+                      "value": 111
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "t",
+                  "value": 116
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 8,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[^o]t\\b/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[^o]t\\b/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[^o]t\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[^o]t\\b",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[^o]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "o",
+                      "value": 111
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "t",
+                  "value": 116
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 8,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[^𝌆]/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/[^𝌆]/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "[^𝌆]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "[^𝌆]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[^𝌆]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "𝌆",
+                      "value": 119558
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[^💚]/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/[^💚]/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "[^💚]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "[^💚]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[^💚]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "💚",
+                      "value": 128154
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[^💛]$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[^💛]$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "[^💛]$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "[^💛]$",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[^💛]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "💛",
+                      "value": 128155
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-b]/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/[a-b]/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "[a-b]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "[a-b]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-b]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-b",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "b",
+                        "value": 98
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-b]?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/[a-b]?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "[a-b]?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "[a-b]?",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "[a-b]?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 6,
+                    "raw": "[a-b]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 5,
+                        "raw": "a-b",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-c\\d]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[a-c\\d]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[a-c\\d]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[a-c\\d]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "[a-c\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 8,
+                    "raw": "[a-c\\d]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 5,
+                        "raw": "a-c",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 7,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-e](?!Z)*/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/[a-e](?!Z)*/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[a-e](?!Z)*",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[a-e](?!Z)*",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-e]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-e",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "e",
+                        "value": 101
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 12,
+                  "raw": "(?!Z)*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 11,
+                    "raw": "(?!Z)",
+                    "kind": "lookahead",
+                    "negate": true,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 10,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-e](?!Z)*?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[a-e](?!Z)*?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "[a-e](?!Z)*?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "[a-e](?!Z)*?",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-e]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-e",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "e",
+                        "value": 101
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 13,
+                  "raw": "(?!Z)*?",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": false,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 11,
+                    "raw": "(?!Z)",
+                    "kind": "lookahead",
+                    "negate": true,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 10,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-e](?!Z)+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/[a-e](?!Z)+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[a-e](?!Z)+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[a-e](?!Z)+",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-e]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-e",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "e",
+                        "value": 101
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 12,
+                  "raw": "(?!Z)+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 11,
+                    "raw": "(?!Z)",
+                    "kind": "lookahead",
+                    "negate": true,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 10,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-e](?!Z)+?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[a-e](?!Z)+?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "[a-e](?!Z)+?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "[a-e](?!Z)+?",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-e]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-e",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "e",
+                        "value": 101
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 13,
+                  "raw": "(?!Z)+?",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": false,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 11,
+                    "raw": "(?!Z)",
+                    "kind": "lookahead",
+                    "negate": true,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 10,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-e](?!Z)?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/[a-e](?!Z)?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[a-e](?!Z)?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[a-e](?!Z)?",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-e]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-e",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "e",
+                        "value": 101
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 12,
+                  "raw": "(?!Z)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 11,
+                    "raw": "(?!Z)",
+                    "kind": "lookahead",
+                    "negate": true,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 10,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-e](?!Z)??/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/[a-e](?!Z)??/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "[a-e](?!Z)??",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "[a-e](?!Z)??",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-e]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-e",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "e",
+                        "value": 101
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 13,
+                  "raw": "(?!Z)??",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": false,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 11,
+                    "raw": "(?!Z)",
+                    "kind": "lookahead",
+                    "negate": true,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 10,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-e](?!Z){2,3}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/[a-e](?!Z){2,3}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "[a-e](?!Z){2,3}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "[a-e](?!Z){2,3}",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-e]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-e",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "e",
+                        "value": 101
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 16,
+                  "raw": "(?!Z){2,3}",
+                  "min": 2,
+                  "max": 3,
+                  "greedy": true,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 11,
+                    "raw": "(?!Z)",
+                    "kind": "lookahead",
+                    "negate": true,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 10,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-e](?!Z){2,3}?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/[a-e](?!Z){2,3}?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "[a-e](?!Z){2,3}?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "[a-e](?!Z){2,3}?",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-e]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-e",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "e",
+                        "value": 101
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 17,
+                  "raw": "(?!Z){2,3}?",
+                  "min": 2,
+                  "max": 3,
+                  "greedy": false,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 11,
+                    "raw": "(?!Z)",
+                    "kind": "lookahead",
+                    "negate": true,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 10,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 18,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-e](?!Z){2,}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/[a-e](?!Z){2,}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "[a-e](?!Z){2,}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "[a-e](?!Z){2,}",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-e]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-e",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "e",
+                        "value": 101
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 15,
+                  "raw": "(?!Z){2,}",
+                  "min": 2,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 11,
+                    "raw": "(?!Z)",
+                    "kind": "lookahead",
+                    "negate": true,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 10,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-e](?!Z){2,}?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/[a-e](?!Z){2,}?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "[a-e](?!Z){2,}?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "[a-e](?!Z){2,}?",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-e]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-e",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "e",
+                        "value": 101
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 16,
+                  "raw": "(?!Z){2,}?",
+                  "min": 2,
+                  "max": "$$Infinity",
+                  "greedy": false,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 11,
+                    "raw": "(?!Z)",
+                    "kind": "lookahead",
+                    "negate": true,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 10,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-e](?!Z){2}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/[a-e](?!Z){2}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "[a-e](?!Z){2}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "[a-e](?!Z){2}",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-e]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-e",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "e",
+                        "value": 101
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 14,
+                  "raw": "(?!Z){2}",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 11,
+                    "raw": "(?!Z)",
+                    "kind": "lookahead",
+                    "negate": true,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 10,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-e](?!Z){2}?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/[a-e](?!Z){2}?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "[a-e](?!Z){2}?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "[a-e](?!Z){2}?",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-e]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-e",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "e",
+                        "value": 101
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 15,
+                  "raw": "(?!Z){2}?",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": false,
+                  "element": {
+                    "type": "Assertion",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 11,
+                    "raw": "(?!Z)",
+                    "kind": "lookahead",
+                    "negate": true,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 10,
+                        "raw": "Z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "Z",
+                            "value": 90
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-f]d/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/[a-f]d/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "[a-f]d",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "[a-f]d",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-f]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-f",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "f",
+                        "value": 102
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-z]+(\\d+)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/[a-z]+(\\d+)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "[a-z]+(\\d+)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "[a-z]+(\\d+)",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "[a-z]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 6,
+                    "raw": "[a-z]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 5,
+                        "raw": "a-z",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "z",
+                          "value": 122
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 12,
+                  "raw": "(\\d+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 11,
+                      "raw": "\\d+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 11,
+                          "raw": "\\d+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 8,
+                            "end": 10,
+                            "raw": "\\d",
+                            "kind": "digit",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-z]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/[a-z]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "[a-z]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "[a-z]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "[a-z]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 6,
+                    "raw": "[a-z]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 5,
+                        "raw": "a-z",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "z",
+                          "value": 122
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-z]+/ig": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[a-z]+/ig",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "[a-z]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "[a-z]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "[a-z]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 6,
+                    "raw": "[a-z]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 5,
+                        "raw": "a-z",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "z",
+                          "value": 122
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 10,
+          "raw": "ig",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-z]+\\d+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/[a-z]+\\d+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "[a-z]+\\d+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "[a-z]+\\d+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "[a-z]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 6,
+                    "raw": "[a-z]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 5,
+                        "raw": "a-z",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "z",
+                          "value": 122
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 10,
+                  "raw": "\\d+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 7,
+                    "end": 9,
+                    "raw": "\\d",
+                    "kind": "digit",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-z]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/[a-z]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "[a-z]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "[a-z]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-z]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-z",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-z][^1-9][a-z]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/[a-z][^1-9][a-z]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "[a-z][^1-9][a-z]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "[a-z][^1-9][a-z]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-z]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-z",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 12,
+                  "raw": "[^1-9]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 11,
+                      "raw": "1-9",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 8,
+                        "end": 9,
+                        "raw": "1",
+                        "value": 49
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 11,
+                        "raw": "9",
+                        "value": 57
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 17,
+                  "raw": "[a-z]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 16,
+                      "raw": "a-z",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 13,
+                        "end": 14,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 15,
+                        "end": 16,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 18,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[a-z]n/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/[a-z]n/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "[a-z]n",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "[a-z]n",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[a-z]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "a-z",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "n",
+                  "value": 110
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[d-h]+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/[d-h]+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "[d-h]+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "[d-h]+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "[d-h]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 6,
+                    "raw": "[d-h]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 5,
+                        "raw": "d-h",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "h",
+                          "value": 104
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[f-z]e\\B/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[f-z]e\\B/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "[f-z]e\\B",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "[f-z]e\\B",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "[f-z]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 5,
+                      "raw": "f-z",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "f",
+                        "value": 102
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 9,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[xyz]*1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/[xyz]*1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[xyz]*1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[xyz]*1",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "[xyz]*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 6,
+                    "raw": "[xyz]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 2,
+                        "end": 3,
+                        "raw": "x",
+                        "value": 120
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "y",
+                        "value": 121
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "1",
+                  "value": 49
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[💩-💫]/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/[💩-💫]/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "[💩-💫]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "[💩-💫]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "[💩-💫]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 7,
+                      "raw": "💩-💫",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 2,
+                        "end": 4,
+                        "raw": "💩",
+                        "value": 128169
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 7,
+                        "raw": "💫",
+                        "value": 128171
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\": {
+      "error": {
+        "message": "Invalid regular expression: /\\: Unterminated regular expression",
+        "index": 2
+      }
+    },
+    "/\\ /": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\ /",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\ ",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\ ",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\ ",
+                  "value": 32
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\*/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\*/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\*",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\*",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\*",
+                  "value": 42
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\.14/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\.14/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\.14",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\.14",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\.",
+                  "value": 46
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "1",
+                  "value": 49
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "4",
+                  "value": 52
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\00/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\00/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\00",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\00",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\00",
+                  "value": 0
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\000/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\000/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\000",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\000",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\000",
+                  "value": 0
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\0003/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/\\0003/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "\\0003",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "\\0003",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\000",
+                  "value": 0
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "3",
+                  "value": 51
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\0022/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/\\0022/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "\\0022",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "\\0022",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\002",
+                  "value": 2
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "2",
+                  "value": 50
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\007/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\007/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\007",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\007",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\007",
+                  "value": 7
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\0111/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/\\0111/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "\\0111",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "\\0111",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\011",
+                  "value": 9
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "1",
+                  "value": 49
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\07/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\07/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\07",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\07",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\07",
+                  "value": 7
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\070/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\070/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\070",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\070",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\070",
+                  "value": 56
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\0፬$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/\\0፬$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\0፬$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\0፬$",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\0",
+                  "value": 0
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "፬",
+                  "value": 4972
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 7,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\0②/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\0②/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\0②",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\0②",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\0",
+                  "value": 0
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "②",
+                  "value": 9313
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\1(A)(B)\\2/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/\\1(A)(B)\\2/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "\\1(A)(B)\\2",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "\\1(A)(B)\\2",
+              "elements": [
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 6,
+                  "raw": "(A)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "A",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "A",
+                          "value": 65
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../0"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 9,
+                  "raw": "(B)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "B",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "B",
+                          "value": 66
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "\\2",
+                  "ref": 2,
+                  "ambiguous": false,
+                  "resolved": "♻️../2"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\1(A)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/\\1(A)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "\\1(A)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "\\1(A)",
+              "elements": [
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 6,
+                  "raw": "(A)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "A",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "A",
+                          "value": 65
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../0"
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\2/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\2/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\2",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\2",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\2",
+                  "value": 2
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\3/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\3/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\3",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\3",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\3",
+                  "value": 3
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\30/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\30/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\30",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\30",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\30",
+                  "value": 24
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\300/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\300/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\300",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\300",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\300",
+                  "value": 192
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\307/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\307/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\307",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\307",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\307",
+                  "value": 199
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\37/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\37/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\37",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\37",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\37",
+                  "value": 31
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\370/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\370/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\370",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\370",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\370",
+                  "value": 248
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\4/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\4/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\4",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\4",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\4",
+                  "value": 4
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\40/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\40/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\40",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\40",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\40",
+                  "value": 32
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\47/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\47/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\47",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\47",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\47",
+                  "value": 39
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\470/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\470/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\470",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\470",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\47",
+                  "value": 39
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "0",
+                  "value": 48
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\5/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\5/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\5",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\5",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\5",
+                  "value": 5
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\6/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\6/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\6",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\6",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\6",
+                  "value": 6
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\7/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\7/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\7",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\7",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\7",
+                  "value": 7
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\70/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\70/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\70",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\70",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\70",
+                  "value": 56
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\700/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\700/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\700",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\700",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\70",
+                  "value": 56
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "0",
+                  "value": 48
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\77/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\77/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\77",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\77",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\77",
+                  "value": 63
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\770/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\770/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\770",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\770",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\77",
+                  "value": 63
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "0",
+                  "value": 48
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\8/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\8/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\8",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\8",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\8",
+                  "value": 56
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\8/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\8/u: Invalid escape",
+        "index": 3
+      }
+    },
+    "/\\9/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\9/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\9",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\9",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\9",
+                  "value": 57
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\;/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\;/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\;",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\;",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\;",
+                  "value": 59
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\??\\??\\??\\??\\??/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/\\??\\??\\??\\??\\??/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "\\??\\??\\??\\??\\??",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "\\??\\??\\??\\??\\??",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\??",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\?",
+                    "value": 63
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 7,
+                  "raw": "\\??",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 4,
+                    "end": 6,
+                    "raw": "\\?",
+                    "value": 63
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 10,
+                  "raw": "\\??",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 7,
+                    "end": 9,
+                    "raw": "\\?",
+                    "value": 63
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 13,
+                  "raw": "\\??",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 10,
+                    "end": 12,
+                    "raw": "\\?",
+                    "value": 63
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 16,
+                  "raw": "\\??",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 13,
+                    "end": 15,
+                    "raw": "\\?",
+                    "value": 63
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\B/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\B/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\B",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\B",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\B[^z]{4}\\B/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/\\B[^z]{4}\\B/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "\\B[^z]{4}\\B",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "\\B[^z]{4}\\B",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 10,
+                  "raw": "[^z]{4}",
+                  "min": 4,
+                  "max": 4,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "[^z]",
+                    "unicodeSets": false,
+                    "negate": true,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 12,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\B\\B\\B\\B\\B\\Bbot\\b\\b\\b\\b\\b\\b\\b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/\\B\\B\\B\\B\\B\\Bbot\\b\\b\\b\\b\\b\\b\\b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "\\B\\B\\B\\B\\B\\Bbot\\b\\b\\b\\b\\b\\b\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "\\B\\B\\B\\B\\B\\Bbot\\b\\b\\b\\b\\b\\b\\b",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 7,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 9,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 13,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "t",
+                  "value": 116
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 18,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 20,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 22,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 24,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 26,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 28,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 30,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 31,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\B\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\B\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\B\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\B\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\B\\w\\B/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\B\\w\\B/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\B\\w\\B",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\B\\w\\B",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 7,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\B\\w{4}\\B/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/\\B\\w{4}\\B/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "\\B\\w{4}\\B",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "\\B\\w{4}\\B",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 8,
+                  "raw": "\\w{4}",
+                  "min": 4,
+                  "max": 4,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "\\w",
+                    "kind": "word",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 10,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\Bevil\\B/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/\\Bevil\\B/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "\\Bevil\\B",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "\\Bevil\\B",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "v",
+                  "value": 118
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "i",
+                  "value": 105
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "l",
+                  "value": 108
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 9,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\Bo\\B/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\Bo\\B/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "\\Bo\\B",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "\\Bo\\B",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 6,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\C/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\C/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\C",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\C",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\C",
+                  "value": 67
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\M/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\M/u: Invalid escape",
+        "index": 2
+      }
+    },
+    "/\\X/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\X/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\X",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\X",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\X",
+                  "value": 88
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\XA0/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\XA0/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\XA0",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\XA0",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\X",
+                  "value": 88
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "A",
+                  "value": 65
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "0",
+                  "value": 48
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\\\/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\\\/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\\\",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\\\",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\\\",
+                  "value": 92
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\b(\\w+) \\1\\b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/\\b(\\w+) \\1\\b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "\\b(\\w+) \\1\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "\\b(\\w+) \\1\\b",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 8,
+                  "raw": "(\\w+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "\\w+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 7,
+                          "raw": "\\w+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 4,
+                            "end": 6,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": " ",
+                  "value": 32
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 13,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\b(\\w+) \\2\\b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/\\b(\\w+) \\2\\b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "\\b(\\w+) \\2\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "\\b(\\w+) \\2\\b",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 8,
+                  "raw": "(\\w+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "\\w+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 7,
+                          "raw": "\\w+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 4,
+                            "end": 6,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": " ",
+                  "value": 32
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "\\2",
+                  "value": 2
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 13,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\b",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\b/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\b/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\b",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\b\\w{5}\\b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/\\b\\w{5}\\b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "\\b\\w{5}\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "\\b\\w{5}\\b",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 8,
+                  "raw": "\\w{5}",
+                  "min": 5,
+                  "max": 5,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "\\w",
+                    "kind": "word",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 10,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\be/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\be/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\be",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\be",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\bop/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\bop/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\bop",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\bop",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "p",
+                  "value": 112
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\bot/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\bot/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\bot",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\bot",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "t",
+                  "value": 116
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\bp/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\bp/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\bp",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\bp",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "p",
+                  "value": 112
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\bro/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\bro/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\bro",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\bro",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "o",
+                  "value": 111
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\brobot\\b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/\\brobot\\b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "\\brobot\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "\\brobot\\b",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "t",
+                  "value": 116
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 10,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\bso/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\bso/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\bso",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\bso",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "s",
+                  "value": 115
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "o",
+                  "value": 111
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\c0/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\c0/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\c0",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\c0",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "\\",
+                  "value": 92
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "0",
+                  "value": 48
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\c0/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\c0/u: Invalid escape",
+        "index": 2
+      }
+    },
+    "/\\c8/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\c8/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\c8",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\c8",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "\\",
+                  "value": 92
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "8",
+                  "value": 56
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\c9/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\c9/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\c9",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\c9",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "\\",
+                  "value": 92
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "9",
+                  "value": 57
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\cY/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\cY/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\cY",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\cY",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\cY",
+                  "value": 25
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\c_/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\c_/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\c_",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\c_",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "\\",
+                  "value": 92
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "_",
+                  "value": 95
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\d+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\d+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\d+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\d+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\d+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\d",
+                    "kind": "digit",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\ddd/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\ddd/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\ddd",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\ddd",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\d",
+                  "kind": "digit",
+                  "negate": false
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\d{1,}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\d{1,}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\d{1,}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\d{1,}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\d{1,}",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\d",
+                    "kind": "digit",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\d{2,4}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/\\d{2,4}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "\\d{2,4}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "\\d{2,4}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "\\d{2,4}",
+                  "min": 2,
+                  "max": 4,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\d",
+                    "kind": "digit",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\d{3}|[a-z]{4}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/\\d{3}|[a-z]{4}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "\\d{3}|[a-z]{4}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "\\d{3}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "\\d{3}",
+                  "min": 3,
+                  "max": 3,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\d",
+                    "kind": "digit",
+                    "negate": false
+                  }
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 7,
+              "end": 15,
+              "raw": "[a-z]{4}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 15,
+                  "raw": "[a-z]{4}",
+                  "min": 4,
+                  "max": 4,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 7,
+                    "end": 12,
+                    "raw": "[a-z]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 8,
+                        "end": 11,
+                        "raw": "a-z",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "z",
+                          "value": 122
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\f\\f/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\f\\f/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\f\\f",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\f\\f",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\f",
+                  "value": 12
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "\\f",
+                  "value": 12
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\k<x>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/\\k<x>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "\\k<x>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "\\k<x>",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\k",
+                  "value": 107
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "<",
+                  "value": 60
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "x",
+                  "value": 120
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ">",
+                  "value": 62
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\n\\n/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\n\\n/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\n\\n",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\n\\n",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\n",
+                  "value": 10
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "\\n",
+                  "value": 10
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\r\\r/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\r\\r/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\r\\r",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\r\\r",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\r",
+                  "value": 13
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "\\r",
+                  "value": 13
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\s+java\\s+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/\\s+java\\s+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "\\s+java\\s+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "\\s+java\\s+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\s+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\s",
+                    "kind": "space",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "j",
+                  "value": 106
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "v",
+                  "value": 118
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 11,
+                  "raw": "\\s+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 8,
+                    "end": 10,
+                    "raw": "\\s",
+                    "kind": "space",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\t/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\t/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\t",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\t",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\t",
+                  "value": 9
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\t\\t/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\t\\t/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\t\\t",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\t\\t",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\t",
+                  "value": 9
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "\\t",
+                  "value": 9
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u0000/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\u0000/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\u0000",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\u0000",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\u0000",
+                  "value": 0
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u0001/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\u0001/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\u0001",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\u0001",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\u0001",
+                  "value": 1
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u000A/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\u000A/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\u000A",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\u000A",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\u000A",
+                  "value": 10
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u0037\\u0037/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/\\u0037\\u0037/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "\\u0037\\u0037",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "\\u0037\\u0037",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\u0037",
+                  "value": 55
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 13,
+                  "raw": "\\u0037",
+                  "value": 55
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u0041/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\u0041/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\u0041",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\u0041",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\u0041",
+                  "value": 65
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u0042/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/\\u0042/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\u0042",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\u0042",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\u0042",
+                  "value": 66
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u00FF/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\u00FF/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\u00FF",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\u00FF",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\u00FF",
+                  "value": 255
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u0FFF/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\u0FFF/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\u0FFF",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\u0FFF",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\u0FFF",
+                  "value": 4095
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u212a/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/\\u212a/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\u212a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\u212a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\u212a",
+                  "value": 8490
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u212a/iu": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/\\u212a/iu",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\u212a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\u212a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\u212a",
+                  "value": 8490
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 10,
+          "raw": "iu",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u212a/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/\\u212a/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\u212a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\u212a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\u212a",
+                  "value": 8490
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\uFFFF/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\uFFFF/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\uFFFF",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\uFFFF",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\uFFFF",
+                  "value": 65535
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\ua/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\ua/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\ua",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\ua",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\u",
+                  "value": 117
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\ud834\\udf06/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/\\ud834\\udf06/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "\\ud834\\udf06",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "\\ud834\\udf06",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "\\ud834\\udf06",
+                  "value": 119558
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u{000000003f}/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/\\u{000000003f}/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "\\u{000000003f}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "\\u{000000003f}",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "\\u{000000003f}",
+                  "value": 63
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u{0}/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\u{0}/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "\\u{0}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "\\u{0}",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "\\u{0}",
+                  "value": 0
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u{1,}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\u{1,}/u: Invalid unicode escape",
+        "index": 3
+      }
+    },
+    "/\\u{10ffff}/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/\\u{10ffff}/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "\\u{10ffff}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "\\u{10ffff}",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "\\u{10ffff}",
+                  "value": 1114111
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u{1d306}/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/\\u{1d306}/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "\\u{1d306}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "\\u{1d306}",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "\\u{1d306}",
+                  "value": 119558
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u{1}/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\u{1}/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "\\u{1}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "\\u{1}",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "\\u{1}",
+                  "value": 1
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u{3F}/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/\\u{3F}/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\u{3F}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\u{3F}",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\u{3F}",
+                  "value": 63
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\u{3f}/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/\\u{3f}/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "\\u{3f}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "\\u{3f}",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "\\u{3f}",
+                  "value": 63
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\v\\v/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\v\\v/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\v\\v",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\v\\v",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\v",
+                  "value": 11
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "\\v",
+                  "value": 11
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\w\\B/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\w\\B/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\w\\B",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\w\\B",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\w{3}\\d?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/\\w{3}\\d?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "\\w{3}\\d?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "\\w{3}\\d?",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "\\w{3}",
+                  "min": 3,
+                  "max": 3,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\w",
+                    "kind": "word",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 9,
+                  "raw": "\\d?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 8,
+                    "raw": "\\d",
+                    "kind": "digit",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\x/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/\\x/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "\\x",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "\\x",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\x",
+                  "value": 120
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\x00/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\x00/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\x00",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\x00",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\x00",
+                  "value": 0
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\x01/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\x01/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\x01",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\x01",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\x01",
+                  "value": 1
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\x0A/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\x0A/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\x0A",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\x0A",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\x0A",
+                  "value": 10
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\xA0/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\xA0/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\xA0",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\xA0",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\xA0",
+                  "value": 160
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\xFF/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\xFF/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\xFF",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\xFF",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "\\xFF",
+                  "value": 255
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\xa/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/\\xa/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "\\xa",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "\\xa",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\x",
+                  "value": 120
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^(([a-z]+)*([a-z])\\.)+[a-z]{2,}$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^(([a-z]+)*([a-z])\\.)+[a-z]{2,}$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^(([a-z]+)*([a-z])\\.)+[a-z]{2,}$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^(([a-z]+)*([a-z])\\.)+[a-z]{2,}$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "(([a-z]+)*([a-z])\\.)+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "(([a-z]+)*([a-z])\\.)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 21,
+                        "raw": "([a-z]+)*([a-z])\\.",
+                        "elements": [
+                          {
+                            "type": "Quantifier",
+                            "parent": "♻️../..",
+                            "start": 3,
+                            "end": 12,
+                            "raw": "([a-z]+)*",
+                            "min": 0,
+                            "max": "$$Infinity",
+                            "greedy": true,
+                            "element": {
+                              "type": "CapturingGroup",
+                              "parent": "♻️..",
+                              "start": 3,
+                              "end": 11,
+                              "raw": "([a-z]+)",
+                              "name": null,
+                              "alternatives": [
+                                {
+                                  "type": "Alternative",
+                                  "parent": "♻️../..",
+                                  "start": 4,
+                                  "end": 10,
+                                  "raw": "[a-z]+",
+                                  "elements": [
+                                    {
+                                      "type": "Quantifier",
+                                      "parent": "♻️../..",
+                                      "start": 4,
+                                      "end": 10,
+                                      "raw": "[a-z]+",
+                                      "min": 1,
+                                      "max": "$$Infinity",
+                                      "greedy": true,
+                                      "element": {
+                                        "type": "CharacterClass",
+                                        "parent": "♻️..",
+                                        "start": 4,
+                                        "end": 9,
+                                        "raw": "[a-z]",
+                                        "unicodeSets": false,
+                                        "negate": false,
+                                        "elements": [
+                                          {
+                                            "type": "CharacterClassRange",
+                                            "parent": "♻️../..",
+                                            "start": 5,
+                                            "end": 8,
+                                            "raw": "a-z",
+                                            "min": {
+                                              "type": "Character",
+                                              "parent": "♻️..",
+                                              "start": 5,
+                                              "end": 6,
+                                              "raw": "a",
+                                              "value": 97
+                                            },
+                                            "max": {
+                                              "type": "Character",
+                                              "parent": "♻️..",
+                                              "start": 7,
+                                              "end": 8,
+                                              "raw": "z",
+                                              "value": 122
+                                            }
+                                          }
+                                        ]
+                                      }
+                                    }
+                                  ]
+                                }
+                              ],
+                              "references": []
+                            }
+                          },
+                          {
+                            "type": "CapturingGroup",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 19,
+                            "raw": "([a-z])",
+                            "name": null,
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 18,
+                                "raw": "[a-z]",
+                                "elements": [
+                                  {
+                                    "type": "CharacterClass",
+                                    "parent": "♻️../..",
+                                    "start": 13,
+                                    "end": 18,
+                                    "raw": "[a-z]",
+                                    "unicodeSets": false,
+                                    "negate": false,
+                                    "elements": [
+                                      {
+                                        "type": "CharacterClassRange",
+                                        "parent": "♻️../..",
+                                        "start": 14,
+                                        "end": 17,
+                                        "raw": "a-z",
+                                        "min": {
+                                          "type": "Character",
+                                          "parent": "♻️..",
+                                          "start": 14,
+                                          "end": 15,
+                                          "raw": "a",
+                                          "value": 97
+                                        },
+                                        "max": {
+                                          "type": "Character",
+                                          "parent": "♻️..",
+                                          "start": 16,
+                                          "end": 17,
+                                          "raw": "z",
+                                          "value": 122
+                                        }
+                                      }
+                                    ]
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 19,
+                            "end": 21,
+                            "raw": "\\.",
+                            "value": 46
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 32,
+                  "raw": "[a-z]{2,}",
+                  "min": 2,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 23,
+                    "end": 28,
+                    "raw": "[a-z]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 24,
+                        "end": 27,
+                        "raw": "a-z",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 24,
+                          "end": 25,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 26,
+                          "end": 27,
+                          "raw": "z",
+                          "value": 122
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 34,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^(([a-z]+)*[a-z]\\.)+[a-z]{2,}$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^(([a-z]+)*[a-z]\\.)+[a-z]{2,}$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^(([a-z]+)*[a-z]\\.)+[a-z]{2,}$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^(([a-z]+)*[a-z]\\.)+[a-z]{2,}$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "(([a-z]+)*[a-z]\\.)+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "(([a-z]+)*[a-z]\\.)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 19,
+                        "raw": "([a-z]+)*[a-z]\\.",
+                        "elements": [
+                          {
+                            "type": "Quantifier",
+                            "parent": "♻️../..",
+                            "start": 3,
+                            "end": 12,
+                            "raw": "([a-z]+)*",
+                            "min": 0,
+                            "max": "$$Infinity",
+                            "greedy": true,
+                            "element": {
+                              "type": "CapturingGroup",
+                              "parent": "♻️..",
+                              "start": 3,
+                              "end": 11,
+                              "raw": "([a-z]+)",
+                              "name": null,
+                              "alternatives": [
+                                {
+                                  "type": "Alternative",
+                                  "parent": "♻️../..",
+                                  "start": 4,
+                                  "end": 10,
+                                  "raw": "[a-z]+",
+                                  "elements": [
+                                    {
+                                      "type": "Quantifier",
+                                      "parent": "♻️../..",
+                                      "start": 4,
+                                      "end": 10,
+                                      "raw": "[a-z]+",
+                                      "min": 1,
+                                      "max": "$$Infinity",
+                                      "greedy": true,
+                                      "element": {
+                                        "type": "CharacterClass",
+                                        "parent": "♻️..",
+                                        "start": 4,
+                                        "end": 9,
+                                        "raw": "[a-z]",
+                                        "unicodeSets": false,
+                                        "negate": false,
+                                        "elements": [
+                                          {
+                                            "type": "CharacterClassRange",
+                                            "parent": "♻️../..",
+                                            "start": 5,
+                                            "end": 8,
+                                            "raw": "a-z",
+                                            "min": {
+                                              "type": "Character",
+                                              "parent": "♻️..",
+                                              "start": 5,
+                                              "end": 6,
+                                              "raw": "a",
+                                              "value": 97
+                                            },
+                                            "max": {
+                                              "type": "Character",
+                                              "parent": "♻️..",
+                                              "start": 7,
+                                              "end": 8,
+                                              "raw": "z",
+                                              "value": 122
+                                            }
+                                          }
+                                        ]
+                                      }
+                                    }
+                                  ]
+                                }
+                              ],
+                              "references": []
+                            }
+                          },
+                          {
+                            "type": "CharacterClass",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 17,
+                            "raw": "[a-z]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterClassRange",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 16,
+                                "raw": "a-z",
+                                "min": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                "max": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 15,
+                                  "end": 16,
+                                  "raw": "z",
+                                  "value": 122
+                                }
+                              }
+                            ]
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 17,
+                            "end": 19,
+                            "raw": "\\.",
+                            "value": 46
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 30,
+                  "raw": "[a-z]{2,}",
+                  "min": 2,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 21,
+                    "end": 26,
+                    "raw": "[a-z]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 22,
+                        "end": 25,
+                        "raw": "a-z",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 22,
+                          "end": 23,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 24,
+                          "end": 25,
+                          "raw": "z",
+                          "value": 122
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 32,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^(A)?(A.*)$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^(A)?(A.*)$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^(A)?(A.*)$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^(A)?(A.*)$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 6,
+                  "raw": "(A)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 5,
+                    "raw": "(A)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "A",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 3,
+                            "end": 4,
+                            "raw": "A",
+                            "value": 65
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 11,
+                  "raw": "(A.*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 10,
+                      "raw": "A.*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "A",
+                          "value": 65
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 10,
+                          "raw": ".*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^([a-z]+)*[a-z]$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^([a-z]+)*[a-z]$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^([a-z]+)*[a-z]$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^([a-z]+)*[a-z]$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "([a-z]+)*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "([a-z]+)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 9,
+                        "raw": "[a-z]+",
+                        "elements": [
+                          {
+                            "type": "Quantifier",
+                            "parent": "♻️../..",
+                            "start": 3,
+                            "end": 9,
+                            "raw": "[a-z]+",
+                            "min": 1,
+                            "max": "$$Infinity",
+                            "greedy": true,
+                            "element": {
+                              "type": "CharacterClass",
+                              "parent": "♻️..",
+                              "start": 3,
+                              "end": 8,
+                              "raw": "[a-z]",
+                              "unicodeSets": false,
+                              "negate": false,
+                              "elements": [
+                                {
+                                  "type": "CharacterClassRange",
+                                  "parent": "♻️../..",
+                                  "start": 4,
+                                  "end": 7,
+                                  "raw": "a-z",
+                                  "min": {
+                                    "type": "Character",
+                                    "parent": "♻️..",
+                                    "start": 4,
+                                    "end": 5,
+                                    "raw": "a",
+                                    "value": 97
+                                  },
+                                  "max": {
+                                    "type": "Character",
+                                    "parent": "♻️..",
+                                    "start": 6,
+                                    "end": 7,
+                                    "raw": "z",
+                                    "value": 122
+                                  }
+                                }
+                              ]
+                            }
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 16,
+                  "raw": "[a-z]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 15,
+                      "raw": "a-z",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 12,
+                        "end": 13,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 14,
+                        "end": 15,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 18,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^.*(:|$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/^.*(:|$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^.*(:|$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^.*(:|$)",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 3,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 9,
+                  "raw": "(:|$)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": ":",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": ":",
+                          "value": 58
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "$",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^.*?$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/^.*?$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "^.*?$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "^.*?$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": ".*?",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": false,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 3,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^.*?(:|$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^.*?(:|$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^.*?(:|$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^.*?(:|$)",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": ".*?",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": false,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 3,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 10,
+                  "raw": "(:|$)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ":",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ":",
+                          "value": 58
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "$",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^.*?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/^.*?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "^.*?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "^.*?",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": ".*?",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": false,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 3,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^..^e/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/^..^e/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "^..^e",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "^..^e",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^[\\ud800\\udc00]$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^[\\ud800\\udc00]$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^[\\ud800\\udc00]$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^[\\ud800\\udc00]$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "[\\ud800\\udc00]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 15,
+                      "raw": "\\ud800\\udc00",
+                      "value": 65536
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^[\\ud834\\udf06]$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^[\\ud834\\udf06]$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^[\\ud834\\udf06]$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^[\\ud834\\udf06]$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "[\\ud834\\udf06]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 15,
+                      "raw": "\\ud834\\udf06",
+                      "value": 119558
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^[^p]/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/^[^p]/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "^[^p]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "^[^p]",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 6,
+                  "raw": "[^p]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "p",
+                      "value": 112
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^[^❤️]$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/^[^❤️]$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "^[^❤️]$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "^[^❤️]$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 7,
+                  "raw": "[^❤️]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "❤",
+                      "value": 10084
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "️",
+                      "value": 65039
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^[^🧡]/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/^[^🧡]/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "^[^🧡]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "^[^🧡]",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 7,
+                  "raw": "[^🧡]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "🧡",
+                      "value": 129505
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^[𝌆]$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/^[𝌆]$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "^[𝌆]$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "^[𝌆]$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 6,
+                  "raw": "[𝌆]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "𝌆",
+                      "value": 119558
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\0a$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/^\\0a$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "^\\0a$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "^\\0a$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "\\0",
+                  "value": 0
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\S$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/^\\S$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "^\\S$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "^\\S$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "\\S",
+                  "kind": "space",
+                  "negate": true
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 7,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\^+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/^\\^+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "^\\^+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "^\\^+",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "\\^+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 4,
+                    "raw": "\\^",
+                    "value": 94
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\d+/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/^\\d+/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "^\\d+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "^\\d+",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "\\d+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 4,
+                    "raw": "\\d",
+                    "kind": "digit",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 7,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^^^^^^^robot$$$$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^^^^^^^robot$$$$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^^^^^^^robot$$$$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^^^^^^^robot$$$$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "t",
+                  "value": 116
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 18,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^a/my": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/^a/my",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "^a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "^a",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 6,
+          "raw": "my",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^a/y": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/^a/y",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "^a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "^a",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "y",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^ab/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/^ab/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "^ab",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "^ab",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^m/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/^m/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "^m",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "^m",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "m",
+                  "value": 109
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^m/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/^m/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "^m",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "^m",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "m",
+                  "value": 109
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^p[a-z]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/^p[a-z]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "^p[a-z]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "^p[a-z]",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "p",
+                  "value": 112
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 8,
+                  "raw": "[a-z]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "a-z",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 7,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^p[b-z]/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/^p[b-z]/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "^p[b-z]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "^p[b-z]",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "p",
+                  "value": 112
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 8,
+                  "raw": "[b-z]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "b-z",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "b",
+                        "value": 98
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 7,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^xxx/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/^xxx/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "^xxx",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "^xxx",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "x",
+                  "value": 120
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "x",
+                  "value": 120
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "x",
+                  "value": 120
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^|^/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/^|^/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "^|^",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "^",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 3,
+              "end": 4,
+              "raw": "^",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "^",
+                  "kind": "start"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a": {
+      "error": {
+        "message": "Invalid regular expression: /a: Unterminated regular expression",
+        "index": 2
+      }
+    },
+    "/a(..(..)..)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/a(..(..)..)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "a(..(..)..)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "a(..(..)..)",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "(..(..)..)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 11,
+                      "raw": "..(..)..",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 9,
+                          "raw": "(..)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 8,
+                              "raw": "..",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 7,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": ".",
+                                  "kind": "any"
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a(.?)b\\1c\\1d\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/a(.?)b\\1c\\1d\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "a(.?)b\\1c\\1d\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "a(.?)b\\1c\\1d\\1",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 6,
+                  "raw": "(.?)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": ".?",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 5,
+                          "raw": ".?",
+                          "min": 0,
+                          "max": 1,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 3,
+                            "end": 4,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3",
+                    "♻️../5",
+                    "♻️../7"
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 9,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 12,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 15,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a(bc)d(ef)g/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/a(bc)d(ef)g/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "a(bc)d(ef)g",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "a(bc)d(ef)g",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 6,
+                  "raw": "(bc)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "bc",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 11,
+                  "raw": "(ef)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 10,
+                      "raw": "ef",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "f",
+                          "value": 102
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "g",
+                  "value": 103
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a[]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/a[]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "a[]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "a[]",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "[]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a[^1-9]c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/a[^1-9]c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "a[^1-9]c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "a[^1-9]c",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "[^1-9]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "1-9",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "1",
+                        "value": 49
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 7,
+                        "raw": "9",
+                        "value": 57
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a[^]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/a[^]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "a[^]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "a[^]",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "[^]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a[^b-z]\\s+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/a[^b-z]\\s+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "a[^b-z]\\s+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "a[^b-z]\\s+",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "[^b-z]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "b-z",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "b",
+                        "value": 98
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 7,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 11,
+                  "raw": "\\s+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 8,
+                    "end": 10,
+                    "raw": "\\s",
+                    "kind": "space",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a[^b]c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/a[^b]c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "a[^b]c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "a[^b]c",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 6,
+                  "raw": "[^b]",
+                  "unicodeSets": false,
+                  "negate": true,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "b",
+                      "value": 98
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a[a-z]{2,4}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/a[a-z]{2,4}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "a[a-z]{2,4}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "a[a-z]{2,4}",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "[a-z]{2,4}",
+                  "min": 2,
+                  "max": 4,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "[a-z]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 6,
+                        "raw": "a-z",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "z",
+                          "value": 122
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a[a-z]{2,4}?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/a[a-z]{2,4}?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "a[a-z]{2,4}?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "a[a-z]{2,4}?",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "[a-z]{2,4}?",
+                  "min": 2,
+                  "max": 4,
+                  "greedy": false,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "[a-z]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 6,
+                        "raw": "a-z",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "z",
+                          "value": 122
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a[b]c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/a[b]c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "a[b]c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "a[b]c",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "[b]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "b",
+                      "value": 98
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a\\": {
+      "error": {
+        "message": "Invalid regular expression: /a\\: Unterminated regular expression",
+        "index": 3
+      }
+    },
+    "/a\\/": {
+      "error": {
+        "message": "Invalid regular expression: /a\\/: Unterminated regular expression",
+        "index": 4
+      }
+    },
+    "/a\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/a\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "a\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "a\\1",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "\\1",
+                  "value": 1
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a\\\\": {
+      "error": {
+        "message": "Invalid regular expression: /a\\\\: Unterminated regular expression",
+        "index": 4
+      }
+    },
+    "/a\\a/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/a\\a/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "a\\a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "a\\a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "\\a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a\\u0041/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/a\\u0041/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "a\\u0041",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "a\\u0041",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\u0041",
+                  "value": 65
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/aa/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/aa/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "aa",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "aa",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/ab.de/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/ab.de/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "ab.de",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "ab.de",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/ab?c?d?x?y?z/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/ab?c?d?x?y?z/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "ab?c?d?x?y?z",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "ab?c?d?x?y?z",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "b?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 3,
+                    "raw": "b",
+                    "value": 98
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 6,
+                  "raw": "c?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 4,
+                    "end": 5,
+                    "raw": "c",
+                    "value": 99
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 8,
+                  "raw": "d?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 7,
+                    "raw": "d",
+                    "value": 100
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 10,
+                  "raw": "x?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 8,
+                    "end": 9,
+                    "raw": "x",
+                    "value": 120
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 12,
+                  "raw": "y?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 10,
+                    "end": 11,
+                    "raw": "y",
+                    "value": 121
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "z",
+                  "value": 122
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/ab[.]?c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/ab[.]?c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "ab[.]?c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "ab[.]?c",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 7,
+                  "raw": "[.]?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "[.]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": ".",
+                        "value": 46
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/ab[ercst]de/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/ab[ercst]de/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "ab[ercst]de",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "ab[ercst]de",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 10,
+                  "raw": "[ercst]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "e",
+                      "value": 101
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "r",
+                      "value": 114
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "c",
+                      "value": 99
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "s",
+                      "value": 115
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "t",
+                      "value": 116
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/ab[erst]de/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/ab[erst]de/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "ab[erst]de",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "ab[erst]de",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 9,
+                  "raw": "[erst]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "e",
+                      "value": 101
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "r",
+                      "value": 114
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "s",
+                      "value": 115
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "t",
+                      "value": 116
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/abc/gi": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/abc/gi",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "abc",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "abc",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 7,
+          "raw": "gi",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/abc/gim": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/abc/gim",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "abc",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "abc",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 8,
+          "raw": "gim",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/abc/ig": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/abc/ig",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "abc",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "abc",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 7,
+          "raw": "ig",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/abcd/ig": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/abcd/ig",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "abcd",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "abcd",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 8,
+          "raw": "ig",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/ab{2,4}c$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/ab{2,4}c$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "ab{2,4}c$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "ab{2,4}c$",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "b{2,4}",
+                  "min": 2,
+                  "max": 4,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 3,
+                    "raw": "b",
+                    "value": 98
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/ab|cd|ef/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/ab|cd|ef/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "ab|cd|ef",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "ab",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 4,
+              "end": 6,
+              "raw": "cd",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 7,
+              "end": 9,
+              "raw": "ef",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/ab|cd|ef/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/ab|cd|ef/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "ab|cd|ef",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "ab",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 4,
+              "end": 6,
+              "raw": "cd",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 7,
+              "end": 9,
+              "raw": "ef",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a|(b)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/a|(b)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "a|(b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 3,
+              "end": 6,
+              "raw": "(b)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 6,
+                  "raw": "(b)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a|ab/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/a|ab/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "a|ab",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 3,
+              "end": 5,
+              "raw": "ab",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a|b|c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/a|b|c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "a|b|c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 3,
+              "end": 4,
+              "raw": "b",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 5,
+              "end": 6,
+              "raw": "c",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b*b+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/b*b+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "b*b+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "b*b+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "b*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "b",
+                    "value": 98
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "b+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "b",
+                    "value": 98
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b?b?b?b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/b?b?b?b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "b?b?b?b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "b?b?b?b",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "b?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "b",
+                    "value": 98
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "b?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "b",
+                    "value": 98
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 7,
+                  "raw": "b?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 5,
+                    "end": 6,
+                    "raw": "b",
+                    "value": 98
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/bc..[\\d]*[\\s]*/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/bc..[\\d]*[\\s]*/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "bc..[\\d]*[\\s]*",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "bc..[\\d]*[\\s]*",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 10,
+                  "raw": "[\\d]*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 5,
+                    "end": 9,
+                    "raw": "[\\d]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 6,
+                        "end": 8,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 15,
+                  "raw": "[\\s]*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 10,
+                    "end": 14,
+                    "raw": "[\\s]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 11,
+                        "end": 13,
+                        "raw": "\\s",
+                        "kind": "space",
+                        "negate": false
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/bx{0,93}c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/bx{0,93}c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "bx{0,93}c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "bx{0,93}c",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "x{0,93}",
+                  "min": 0,
+                  "max": 93,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 3,
+                    "raw": "x",
+                    "value": 120
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b{0,93}c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/b{0,93}c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "b{0,93}c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "b{0,93}c",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "b{0,93}",
+                  "min": 0,
+                  "max": 93,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "b",
+                    "value": 98
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b{2,3}c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/b{2,3}c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "b{2,3}c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "b{2,3}c",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "b{2,3}",
+                  "min": 2,
+                  "max": 3,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "b",
+                    "value": 98
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b{2,}c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/b{2,}c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "b{2,}c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "b{2,}c",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "b{2,}",
+                  "min": 2,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "b",
+                    "value": 98
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b{2}c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/b{2}c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "b{2}c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "b{2}c",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "b{2}",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "b",
+                    "value": 98
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b{42,93}c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/b{42,93}c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "b{42,93}c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "b{42,93}c",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "b{42,93}",
+                  "min": 42,
+                  "max": 93,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "b",
+                    "value": 98
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b{8,}c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/b{8,}c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "b{8,}c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "b{8,}c",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "b{8,}",
+                  "min": 8,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "b",
+                    "value": 98
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b{8}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/b{8}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "b{8}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "b{8}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "b{8}",
+                  "min": 8,
+                  "max": 8,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "b",
+                    "value": 98
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/c[\\b]{3}d/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/c[\\b]{3}d/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "c[\\b]{3}d",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "c[\\b]{3}d",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "[\\b]{3}",
+                  "min": 3,
+                  "max": 3,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 6,
+                    "raw": "[\\b]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\b",
+                        "value": 8
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/cd*/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/cd*/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "cd*",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "cd*",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "d*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 3,
+                    "raw": "d",
+                    "value": 100
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/cd?e/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/cd?e/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "cd?e",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "cd?e",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "d?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 3,
+                    "raw": "d",
+                    "value": 100
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/cdx?e/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/cdx?e/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "cdx?e",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "cdx?e",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "x?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "x",
+                    "value": 120
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/cx*d/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/cx*d/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "cx*d",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "cx*d",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "x*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 3,
+                    "raw": "x",
+                    "value": 120
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/d*/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/d*/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "d*",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "d*",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "d*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "d",
+                    "value": 100
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/d+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/d+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "d+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "d+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "d+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "d",
+                    "value": 100
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "def",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/def/mig": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/def/mig",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "def",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 8,
+          "raw": "mig",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/e$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/e$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "e$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "e$",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/e\\b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/e\\b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "e\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "e\\b",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/es$/mg": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/es$/mg",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "es$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "es$",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "s",
+                  "value": 115
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 7,
+          "raw": "mg",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/e{1}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/e{1}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "e{1}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "e{1}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "e{1}",
+                  "min": 1,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "e",
+                    "value": 101
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/initial/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/initial/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "initial",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "initial",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "i",
+                  "value": 105
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "n",
+                  "value": 110
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "i",
+                  "value": 105
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "t",
+                  "value": 116
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "i",
+                  "value": 105
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "l",
+                  "value": 108
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/java(script)?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/java(script)?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "java(script)?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "java(script)?",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "j",
+                  "value": 106
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "v",
+                  "value": 118
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 14,
+                  "raw": "(script)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 5,
+                    "end": 13,
+                    "raw": "(script)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 6,
+                        "end": 12,
+                        "raw": "script",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "s",
+                            "value": 115
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 7,
+                            "end": 8,
+                            "raw": "c",
+                            "value": 99
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "r",
+                            "value": 114
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "i",
+                            "value": 105
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "p",
+                            "value": 112
+                          },
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 11,
+                            "end": 12,
+                            "raw": "t",
+                            "value": 116
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/l/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 3,
+        "raw": "/l/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "l",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "l",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "l",
+                  "value": 108
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 3,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/ll|l/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/ll|l/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "ll|l",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "ll",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "l",
+                  "value": 108
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "l",
+                  "value": 108
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 4,
+              "end": 5,
+              "raw": "l",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "l",
+                  "value": 108
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/nd|ne/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/nd|ne/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "nd|ne",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "nd",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "n",
+                  "value": 110
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 4,
+              "end": 6,
+              "raw": "ne",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "n",
+                  "value": 110
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/o+/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/o+/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "o+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "o+",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "o+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "o",
+                    "value": 111
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/o?pqrst/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/o?pqrst/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "o?pqrst",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "o?pqrst",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "o?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "o",
+                    "value": 111
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "p",
+                  "value": 112
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "q",
+                  "value": 113
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "s",
+                  "value": 115
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "t",
+                  "value": 116
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/op\\b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/op\\b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "op\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "op\\b",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "p",
+                  "value": 112
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/original value/ig": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/original value/ig",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "original value",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "original value",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "i",
+                  "value": 105
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "g",
+                  "value": 103
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "i",
+                  "value": 105
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "n",
+                  "value": 110
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "l",
+                  "value": 108
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": " ",
+                  "value": 32
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "v",
+                  "value": 118
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "l",
+                  "value": 108
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "u",
+                  "value": 117
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 18,
+          "raw": "ig",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/ot\\b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/ot\\b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "ot\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "ot\\b",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "t",
+                  "value": 116
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/q[ax-zb](?=\\s+)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/q[ax-zb](?=\\s+)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "q[ax-zb](?=\\s+)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "q[ax-zb](?=\\s+)",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "q",
+                  "value": 113
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "[ax-zb]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "a",
+                      "value": 97
+                    },
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "x-z",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "x",
+                        "value": 120
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 7,
+                        "raw": "z",
+                        "value": 122
+                      }
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "b",
+                      "value": 98
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 16,
+                  "raw": "(?=\\s+)",
+                  "kind": "lookahead",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 15,
+                      "raw": "\\s+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 15,
+                          "raw": "\\s+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 12,
+                            "end": 14,
+                            "raw": "\\s",
+                            "kind": "space",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/r\\b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/r\\b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "r\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "r\\b",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "r",
+                  "value": 114
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/s$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/s$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "s$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "s$",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "s",
+                  "value": 115
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 4,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/s$/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/s$/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 3,
+          "raw": "s$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 3,
+              "raw": "s$",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "s",
+                  "value": 115
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 4,
+          "end": 5,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/so\\b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/so\\b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "so\\b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "so\\b",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "s",
+                  "value": 115
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "\\b",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/t[a-b|q-s]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/t[a-b|q-s]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "t[a-b|q-s]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "t[a-b|q-s]",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "t",
+                  "value": 116
+                },
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "[a-b|q-s]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "a-b",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "b",
+                        "value": 98
+                      }
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "|",
+                      "value": 124
+                    },
+                    {
+                      "type": "CharacterClassRange",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 10,
+                      "raw": "q-s",
+                      "min": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 8,
+                        "raw": "q",
+                        "value": 113
+                      },
+                      "max": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 9,
+                        "end": 10,
+                        "raw": "s",
+                        "value": 115
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/test262/ig": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/test262/ig",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "test262",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "test262",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "t",
+                  "value": 116
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "s",
+                  "value": 115
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "t",
+                  "value": 116
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "2",
+                  "value": 50
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "6",
+                  "value": 54
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "2",
+                  "value": 50
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "ig",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/undefined/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/undefined/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "undefined",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "undefined",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "u",
+                  "value": 117
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "n",
+                  "value": 110
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "i",
+                  "value": 105
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "n",
+                  "value": 110
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/updated/gi": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/updated/gi",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "updated",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "updated",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "u",
+                  "value": 117
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "p",
+                  "value": 112
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "t",
+                  "value": 116
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "gi",
+          "global": true,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/x*y+$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/x*y+$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "x*y+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "x*y+$",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "x*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "x",
+                    "value": 120
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "y+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "y",
+                    "value": 121
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/x/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/x/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "x",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "x",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "x",
+                  "value": 120
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/x?ay?bz?c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/x?ay?bz?c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "x?ay?bz?c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "x?ay?bz?c",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "x?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "x",
+                    "value": 120
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 6,
+                  "raw": "y?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 4,
+                    "end": 5,
+                    "raw": "y",
+                    "value": 121
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 9,
+                  "raw": "z?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 7,
+                    "end": 8,
+                    "raw": "z",
+                    "value": 122
+                  }
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/x?y?z?/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/x?y?z?/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "x?y?z?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "x?y?z?",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "x?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "x",
+                    "value": 120
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "y?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "y",
+                    "value": 121
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 7,
+                  "raw": "z?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 5,
+                    "end": 6,
+                    "raw": "z",
+                    "value": 122
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/xyz|.../": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/xyz|.../",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "xyz|...",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "xyz",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "x",
+                  "value": 120
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "y",
+                  "value": 121
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "z",
+                  "value": 122
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 5,
+              "end": 8,
+              "raw": "...",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/x{1,2}x{1,}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/x{1,2}x{1,}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "x{1,2}x{1,}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "x{1,2}x{1,}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "x{1,2}",
+                  "min": 1,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": "x",
+                    "value": 120
+                  }
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 12,
+                  "raw": "x{1,}",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 7,
+                    "end": 8,
+                    "raw": "x",
+                    "value": 120
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/x{o}x/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/x{o}x/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "x{o}x",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "x{o}x",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "x",
+                  "value": 120
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "{",
+                  "value": 123
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "}",
+                  "value": 125
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "x",
+                  "value": 120
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/{2,3}/": {
+      "error": {
+        "message": "Invalid regular expression: /{2,3}/: Nothing to repeat",
+        "index": 6
+      }
+    },
+    "/{2,}/": {
+      "error": {
+        "message": "Invalid regular expression: /{2,}/: Nothing to repeat",
+        "index": 5
+      }
+    },
+    "/{2}/": {
+      "error": {
+        "message": "Invalid regular expression: /{2}/: Nothing to repeat",
+        "index": 4
+      }
+    },
+    "/|()/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/|()/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "|()",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 1,
+              "raw": "",
+              "elements": []
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 2,
+              "end": 4,
+              "raw": "()",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 4,
+                  "raw": "()",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/𝌆{2}/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/𝌆{2}/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "𝌆{2}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "𝌆{2}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "𝌆{2}",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "𝌆",
+                    "value": 119558
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/numeric-separator-literal.json b/test/fixtures/parser/literal/test262/numeric-separator-literal.json
new file mode 100644
index 0000000..08340d9
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/numeric-separator-literal.json
@@ -0,0 +1,14 @@
+{
+  "_test262FileNames": [
+    "test/language/literals/regexp/unicode-escape-nls-err.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/\\u{1F_639}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\u{1F_639}/u: Invalid unicode escape",
+        "index": 3
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/regexp-dotall-and-u180e.json b/test/fixtures/parser/literal/test262/regexp-dotall-and-u180e.json
new file mode 100644
index 0000000..a75226d
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/regexp-dotall-and-u180e.json
@@ -0,0 +1,273 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/dotall/with-dotall-unicode.js",
+    "test/built-ins/RegExp/dotall/with-dotall.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/^.$/s": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/^.$/s",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "^.$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "^.$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "s",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^.$/sm": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/^.$/sm",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "^.$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "^.$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 7,
+          "raw": "sm",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^.$/su": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/^.$/su",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "^.$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "^.$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 7,
+          "raw": "su",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^.$/sum": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/^.$/sum",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "^.$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "^.$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 8,
+          "raw": "sum",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/regexp-dotall.json b/test/fixtures/parser/literal/test262/regexp-dotall.json
new file mode 100644
index 0000000..7abea02
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/regexp-dotall.json
@@ -0,0 +1,369 @@
+{
+  "_test262FileNames": [
+    "test/annexB/built-ins/RegExp/prototype/flags/order-after-compile.js",
+    "test/built-ins/RegExp/prototype/dotAll/this-val-regexp.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/(?:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/(?:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "(?:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "(?:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(?:)",
+                  "modifiers": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 4,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/./i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./is": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./is",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "is",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/./m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./ms": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./ms",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "ms",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./sg": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./sg",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "sg",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./sy": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./sy",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "sy",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/regexp-duplicate-named-groups-and-regexp-match-indices.json b/test/fixtures/parser/literal/test262/regexp-duplicate-named-groups-and-regexp-match-indices.json
new file mode 100644
index 0000000..beda2fd
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/regexp-duplicate-named-groups-and-regexp-match-indices.json
@@ -0,0 +1,543 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/named-groups/duplicate-names-match-indices.js",
+    "test/built-ins/RegExp/prototype/exec/duplicate-named-indices-groups-properties.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/(?:(?:(?<x>a)|(?<x>b)|c)\\k<x>){2}/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/(?:(?:(?<x>a)|(?<x>b)|c)\\k<x>){2}/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "(?:(?:(?<x>a)|(?<x>b)|c)\\k<x>){2}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "(?:(?:(?<x>a)|(?<x>b)|c)\\k<x>){2}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 34,
+                  "raw": "(?:(?:(?<x>a)|(?<x>b)|c)\\k<x>){2}",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "Group",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 31,
+                    "raw": "(?:(?:(?<x>a)|(?<x>b)|c)\\k<x>)",
+                    "modifiers": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 30,
+                        "raw": "(?:(?<x>a)|(?<x>b)|c)\\k<x>",
+                        "elements": [
+                          {
+                            "type": "Group",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 25,
+                            "raw": "(?:(?<x>a)|(?<x>b)|c)",
+                            "modifiers": null,
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 7,
+                                "end": 14,
+                                "raw": "(?<x>a)",
+                                "elements": [
+                                  {
+                                    "type": "CapturingGroup",
+                                    "parent": "♻️../..",
+                                    "start": 7,
+                                    "end": 14,
+                                    "raw": "(?<x>a)",
+                                    "name": "x",
+                                    "alternatives": [
+                                      {
+                                        "type": "Alternative",
+                                        "parent": "♻️../..",
+                                        "start": 12,
+                                        "end": 13,
+                                        "raw": "a",
+                                        "elements": [
+                                          {
+                                            "type": "Character",
+                                            "parent": "♻️../..",
+                                            "start": 12,
+                                            "end": 13,
+                                            "raw": "a",
+                                            "value": 97
+                                          }
+                                        ]
+                                      }
+                                    ],
+                                    "references": [
+                                      "♻️../../../../../1"
+                                    ]
+                                  }
+                                ]
+                              },
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 15,
+                                "end": 22,
+                                "raw": "(?<x>b)",
+                                "elements": [
+                                  {
+                                    "type": "CapturingGroup",
+                                    "parent": "♻️../..",
+                                    "start": 15,
+                                    "end": 22,
+                                    "raw": "(?<x>b)",
+                                    "name": "x",
+                                    "alternatives": [
+                                      {
+                                        "type": "Alternative",
+                                        "parent": "♻️../..",
+                                        "start": 20,
+                                        "end": 21,
+                                        "raw": "b",
+                                        "elements": [
+                                          {
+                                            "type": "Character",
+                                            "parent": "♻️../..",
+                                            "start": 20,
+                                            "end": 21,
+                                            "raw": "b",
+                                            "value": 98
+                                          }
+                                        ]
+                                      }
+                                    ],
+                                    "references": [
+                                      "♻️../../../../../1"
+                                    ]
+                                  }
+                                ]
+                              },
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 23,
+                                "end": 24,
+                                "raw": "c",
+                                "elements": [
+                                  {
+                                    "type": "Character",
+                                    "parent": "♻️../..",
+                                    "start": 23,
+                                    "end": 24,
+                                    "raw": "c",
+                                    "value": 99
+                                  }
+                                ]
+                              }
+                            ]
+                          },
+                          {
+                            "type": "Backreference",
+                            "parent": "♻️../..",
+                            "start": 25,
+                            "end": 30,
+                            "raw": "\\k<x>",
+                            "ref": "x",
+                            "ambiguous": true,
+                            "resolved": [
+                              "♻️../0/alternatives/0/elements/0",
+                              "♻️../0/alternatives/1/elements/0"
+                            ]
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?:(?<x>a)|(?<y>a)(?<x>b))(?:(?<z>c)|(?<z>d))/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 48,
+        "raw": "/(?:(?<x>a)|(?<y>a)(?<x>b))(?:(?<z>c)|(?<z>d))/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 46,
+          "raw": "(?:(?<x>a)|(?<y>a)(?<x>b))(?:(?<z>c)|(?<z>d))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 46,
+              "raw": "(?:(?<x>a)|(?<y>a)(?<x>b))(?:(?<z>c)|(?<z>d))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 27,
+                  "raw": "(?:(?<x>a)|(?<y>a)(?<x>b))",
+                  "modifiers": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 11,
+                      "raw": "(?<x>a)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 11,
+                          "raw": "(?<x>a)",
+                          "name": "x",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "a",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 26,
+                      "raw": "(?<y>a)(?<x>b)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 19,
+                          "raw": "(?<y>a)",
+                          "name": "y",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 17,
+                              "end": 18,
+                              "raw": "a",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 17,
+                                  "end": 18,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 26,
+                          "raw": "(?<x>b)",
+                          "name": "x",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 24,
+                              "end": 25,
+                              "raw": "b",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 24,
+                                  "end": 25,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 46,
+                  "raw": "(?:(?<z>c)|(?<z>d))",
+                  "modifiers": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 30,
+                      "end": 37,
+                      "raw": "(?<z>c)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 30,
+                          "end": 37,
+                          "raw": "(?<z>c)",
+                          "name": "z",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 35,
+                              "end": 36,
+                              "raw": "c",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 35,
+                                  "end": 36,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 38,
+                      "end": 45,
+                      "raw": "(?<z>d)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 38,
+                          "end": 45,
+                          "raw": "(?<z>d)",
+                          "name": "z",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 43,
+                              "end": 44,
+                              "raw": "d",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 43,
+                                  "end": 44,
+                                  "raw": "d",
+                                  "value": 100
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 47,
+          "end": 48,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<x>a)|(?<x>b)/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?<x>a)|(?<x>b)/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<x>a)|(?<x>b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<x>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<x>a)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 9,
+              "end": 16,
+              "raw": "(?<x>b)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 16,
+                  "raw": "(?<x>b)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 15,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/regexp-duplicate-named-groups.json b/test/fixtures/parser/literal/test262/regexp-duplicate-named-groups.json
new file mode 100644
index 0000000..0b608a4
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/regexp-duplicate-named-groups.json
@@ -0,0 +1,1902 @@
+{
+  "_test262FileNames": [
+    "test/annexB/built-ins/RegExp/prototype/compile/duplicate-named-capturing-groups-syntax.js",
+    "test/built-ins/RegExp/named-groups/duplicate-names-exec.js",
+    "test/built-ins/RegExp/named-groups/duplicate-names-group-property-enumeration-order.js",
+    "test/built-ins/RegExp/named-groups/duplicate-names-matchall.js",
+    "test/built-ins/RegExp/prototype/exec/duplicate-named-groups-properties.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/(?:(?:(?<x>a)|(?<x>b))\\k<x>){2}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/(?:(?:(?<x>a)|(?<x>b))\\k<x>){2}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "(?:(?:(?<x>a)|(?<x>b))\\k<x>){2}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "(?:(?:(?<x>a)|(?<x>b))\\k<x>){2}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 32,
+                  "raw": "(?:(?:(?<x>a)|(?<x>b))\\k<x>){2}",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "Group",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 29,
+                    "raw": "(?:(?:(?<x>a)|(?<x>b))\\k<x>)",
+                    "modifiers": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 28,
+                        "raw": "(?:(?<x>a)|(?<x>b))\\k<x>",
+                        "elements": [
+                          {
+                            "type": "Group",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 23,
+                            "raw": "(?:(?<x>a)|(?<x>b))",
+                            "modifiers": null,
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 7,
+                                "end": 14,
+                                "raw": "(?<x>a)",
+                                "elements": [
+                                  {
+                                    "type": "CapturingGroup",
+                                    "parent": "♻️../..",
+                                    "start": 7,
+                                    "end": 14,
+                                    "raw": "(?<x>a)",
+                                    "name": "x",
+                                    "alternatives": [
+                                      {
+                                        "type": "Alternative",
+                                        "parent": "♻️../..",
+                                        "start": 12,
+                                        "end": 13,
+                                        "raw": "a",
+                                        "elements": [
+                                          {
+                                            "type": "Character",
+                                            "parent": "♻️../..",
+                                            "start": 12,
+                                            "end": 13,
+                                            "raw": "a",
+                                            "value": 97
+                                          }
+                                        ]
+                                      }
+                                    ],
+                                    "references": [
+                                      "♻️../../../../../1"
+                                    ]
+                                  }
+                                ]
+                              },
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 15,
+                                "end": 22,
+                                "raw": "(?<x>b)",
+                                "elements": [
+                                  {
+                                    "type": "CapturingGroup",
+                                    "parent": "♻️../..",
+                                    "start": 15,
+                                    "end": 22,
+                                    "raw": "(?<x>b)",
+                                    "name": "x",
+                                    "alternatives": [
+                                      {
+                                        "type": "Alternative",
+                                        "parent": "♻️../..",
+                                        "start": 20,
+                                        "end": 21,
+                                        "raw": "b",
+                                        "elements": [
+                                          {
+                                            "type": "Character",
+                                            "parent": "♻️../..",
+                                            "start": 20,
+                                            "end": 21,
+                                            "raw": "b",
+                                            "value": 98
+                                          }
+                                        ]
+                                      }
+                                    ],
+                                    "references": [
+                                      "♻️../../../../../1"
+                                    ]
+                                  }
+                                ]
+                              }
+                            ]
+                          },
+                          {
+                            "type": "Backreference",
+                            "parent": "♻️../..",
+                            "start": 23,
+                            "end": 28,
+                            "raw": "\\k<x>",
+                            "ref": "x",
+                            "ambiguous": true,
+                            "resolved": [
+                              "♻️../0/alternatives/0/elements/0",
+                              "♻️../0/alternatives/1/elements/0"
+                            ]
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 33,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?:(?:(?<x>a)|(?<x>b)|c)\\k<x>){2}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/(?:(?:(?<x>a)|(?<x>b)|c)\\k<x>){2}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "(?:(?:(?<x>a)|(?<x>b)|c)\\k<x>){2}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "(?:(?:(?<x>a)|(?<x>b)|c)\\k<x>){2}",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 34,
+                  "raw": "(?:(?:(?<x>a)|(?<x>b)|c)\\k<x>){2}",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "Group",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 31,
+                    "raw": "(?:(?:(?<x>a)|(?<x>b)|c)\\k<x>)",
+                    "modifiers": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 30,
+                        "raw": "(?:(?<x>a)|(?<x>b)|c)\\k<x>",
+                        "elements": [
+                          {
+                            "type": "Group",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 25,
+                            "raw": "(?:(?<x>a)|(?<x>b)|c)",
+                            "modifiers": null,
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 7,
+                                "end": 14,
+                                "raw": "(?<x>a)",
+                                "elements": [
+                                  {
+                                    "type": "CapturingGroup",
+                                    "parent": "♻️../..",
+                                    "start": 7,
+                                    "end": 14,
+                                    "raw": "(?<x>a)",
+                                    "name": "x",
+                                    "alternatives": [
+                                      {
+                                        "type": "Alternative",
+                                        "parent": "♻️../..",
+                                        "start": 12,
+                                        "end": 13,
+                                        "raw": "a",
+                                        "elements": [
+                                          {
+                                            "type": "Character",
+                                            "parent": "♻️../..",
+                                            "start": 12,
+                                            "end": 13,
+                                            "raw": "a",
+                                            "value": 97
+                                          }
+                                        ]
+                                      }
+                                    ],
+                                    "references": [
+                                      "♻️../../../../../1"
+                                    ]
+                                  }
+                                ]
+                              },
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 15,
+                                "end": 22,
+                                "raw": "(?<x>b)",
+                                "elements": [
+                                  {
+                                    "type": "CapturingGroup",
+                                    "parent": "♻️../..",
+                                    "start": 15,
+                                    "end": 22,
+                                    "raw": "(?<x>b)",
+                                    "name": "x",
+                                    "alternatives": [
+                                      {
+                                        "type": "Alternative",
+                                        "parent": "♻️../..",
+                                        "start": 20,
+                                        "end": 21,
+                                        "raw": "b",
+                                        "elements": [
+                                          {
+                                            "type": "Character",
+                                            "parent": "♻️../..",
+                                            "start": 20,
+                                            "end": 21,
+                                            "raw": "b",
+                                            "value": 98
+                                          }
+                                        ]
+                                      }
+                                    ],
+                                    "references": [
+                                      "♻️../../../../../1"
+                                    ]
+                                  }
+                                ]
+                              },
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 23,
+                                "end": 24,
+                                "raw": "c",
+                                "elements": [
+                                  {
+                                    "type": "Character",
+                                    "parent": "♻️../..",
+                                    "start": 23,
+                                    "end": 24,
+                                    "raw": "c",
+                                    "value": 99
+                                  }
+                                ]
+                              }
+                            ]
+                          },
+                          {
+                            "type": "Backreference",
+                            "parent": "♻️../..",
+                            "start": 25,
+                            "end": 30,
+                            "raw": "\\k<x>",
+                            "ref": "x",
+                            "ambiguous": true,
+                            "resolved": [
+                              "♻️../0/alternatives/0/elements/0",
+                              "♻️../0/alternatives/1/elements/0"
+                            ]
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 35,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?:(?<x>a)|(?<x>b))\\k<x>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/(?:(?<x>a)|(?<x>b))\\k<x>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "(?:(?<x>a)|(?<x>b))\\k<x>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "(?:(?<x>a)|(?<x>b))\\k<x>",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 20,
+                  "raw": "(?:(?<x>a)|(?<x>b))",
+                  "modifiers": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 11,
+                      "raw": "(?<x>a)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 11,
+                          "raw": "(?<x>a)",
+                          "name": "x",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "a",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../1"
+                          ]
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 19,
+                      "raw": "(?<x>b)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 19,
+                          "raw": "(?<x>b)",
+                          "name": "x",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 17,
+                              "end": 18,
+                              "raw": "b",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 17,
+                                  "end": 18,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../1"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 25,
+                  "raw": "\\k<x>",
+                  "ref": "x",
+                  "ambiguous": true,
+                  "resolved": [
+                    "♻️../0/alternatives/0/elements/0",
+                    "♻️../0/alternatives/1/elements/0"
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 26,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?:(?<x>a)|(?<y>a)(?<x>b))(?:(?<z>c)|(?<z>d))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 47,
+        "raw": "/(?:(?<x>a)|(?<y>a)(?<x>b))(?:(?<z>c)|(?<z>d))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 46,
+          "raw": "(?:(?<x>a)|(?<y>a)(?<x>b))(?:(?<z>c)|(?<z>d))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 46,
+              "raw": "(?:(?<x>a)|(?<y>a)(?<x>b))(?:(?<z>c)|(?<z>d))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 27,
+                  "raw": "(?:(?<x>a)|(?<y>a)(?<x>b))",
+                  "modifiers": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 11,
+                      "raw": "(?<x>a)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 11,
+                          "raw": "(?<x>a)",
+                          "name": "x",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "a",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 26,
+                      "raw": "(?<y>a)(?<x>b)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 19,
+                          "raw": "(?<y>a)",
+                          "name": "y",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 17,
+                              "end": 18,
+                              "raw": "a",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 17,
+                                  "end": 18,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 26,
+                          "raw": "(?<x>b)",
+                          "name": "x",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 24,
+                              "end": 25,
+                              "raw": "b",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 24,
+                                  "end": 25,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 46,
+                  "raw": "(?:(?<z>c)|(?<z>d))",
+                  "modifiers": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 30,
+                      "end": 37,
+                      "raw": "(?<z>c)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 30,
+                          "end": 37,
+                          "raw": "(?<z>c)",
+                          "name": "z",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 35,
+                              "end": 36,
+                              "raw": "c",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 35,
+                                  "end": 36,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 38,
+                      "end": 45,
+                      "raw": "(?<z>d)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 38,
+                          "end": 45,
+                          "raw": "(?<z>d)",
+                          "name": "z",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 43,
+                              "end": 44,
+                              "raw": "d",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 43,
+                                  "end": 44,
+                                  "raw": "d",
+                                  "value": 100
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 47,
+          "end": 47,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>x)|(?:zy\\k<a>)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?<a>x)|(?:zy\\k<a>)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?<a>x)|(?:zy\\k<a>)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<a>x)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>x)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "x",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "x",
+                          "value": 120
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../../../1/elements/0/alternatives/0/elements/2"
+                  ]
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 9,
+              "end": 20,
+              "raw": "(?:zy\\k<a>)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 20,
+                  "raw": "(?:zy\\k<a>)",
+                  "modifiers": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 19,
+                      "raw": "zy\\k<a>",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "z",
+                          "value": 122
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "y",
+                          "value": 121
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 19,
+                          "raw": "\\k<a>",
+                          "ref": "a",
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../../../0/elements/0"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<x>a)|(?<x>b)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<x>a)|(?<x>b)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<x>a)|(?<x>b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<x>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<x>a)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 9,
+              "end": 16,
+              "raw": "(?<x>b)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 16,
+                  "raw": "(?<x>b)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 15,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<x>a)|(?<x>b)/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?<x>a)|(?<x>b)/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<x>a)|(?<x>b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<x>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<x>a)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 9,
+              "end": 16,
+              "raw": "(?<x>b)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 16,
+                  "raw": "(?<x>b)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 15,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<x>b)|(?<x>a)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<x>b)|(?<x>a)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<x>b)|(?<x>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<x>b)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<x>b)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 9,
+              "end": 16,
+              "raw": "(?<x>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 16,
+                  "raw": "(?<x>a)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 15,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<x>b)|(?<x>a)/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?<x>b)|(?<x>a)/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<x>b)|(?<x>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<x>b)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<x>b)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 9,
+              "end": 16,
+              "raw": "(?<x>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 16,
+                  "raw": "(?<x>a)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 15,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<y>a)(?<x>a)|(?<x>b)(?<y>b)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/(?<y>a)(?<x>a)|(?<x>b)(?<y>b)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "(?<y>a)(?<x>a)|(?<x>b)(?<y>b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?<y>a)(?<x>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<y>a)",
+                  "name": "y",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 15,
+                  "raw": "(?<x>a)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 14,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 16,
+              "end": 30,
+              "raw": "(?<x>b)(?<y>b)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 23,
+                  "raw": "(?<x>b)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 21,
+                      "end": 22,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 21,
+                          "end": 22,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 30,
+                  "raw": "(?<y>b)",
+                  "name": "y",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 28,
+                      "end": 29,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 28,
+                          "end": 29,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 31,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[ab]/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/[ab]/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "[ab]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "[ab]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "[ab]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "a",
+                      "value": 97
+                    },
+                    {
+                      "type": "Character",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "b",
+                      "value": 98
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^(?:(?<a>x)|(?<a>y)|z)\\k<a>$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^(?:(?<a>x)|(?<a>y)|z)\\k<a>$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^(?:(?<a>x)|(?<a>y)|z)\\k<a>$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^(?:(?<a>x)|(?<a>y)|z)\\k<a>$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "(?:(?<a>x)|(?<a>y)|z)",
+                  "modifiers": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 12,
+                      "raw": "(?<a>x)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 12,
+                          "raw": "(?<a>x)",
+                          "name": "a",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 10,
+                              "end": 11,
+                              "raw": "x",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 10,
+                                  "end": 11,
+                                  "raw": "x",
+                                  "value": 120
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../2"
+                          ]
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 20,
+                      "raw": "(?<a>y)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 20,
+                          "raw": "(?<a>y)",
+                          "name": "a",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 18,
+                              "end": 19,
+                              "raw": "y",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 18,
+                                  "end": 19,
+                                  "raw": "y",
+                                  "value": 121
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../2"
+                          ]
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 21,
+                      "end": 22,
+                      "raw": "z",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 21,
+                          "end": 22,
+                          "raw": "z",
+                          "value": 122
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 28,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": true,
+                  "resolved": [
+                    "♻️../1/alternatives/0/elements/0",
+                    "♻️../1/alternatives/1/elements/0"
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 30,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^(?:(?<a>x)|(?<a>y)|z){2}\\k<a>$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^(?:(?<a>x)|(?<a>y)|z){2}\\k<a>$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^(?:(?<a>x)|(?<a>y)|z){2}\\k<a>$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^(?:(?<a>x)|(?<a>y)|z){2}\\k<a>$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "(?:(?<a>x)|(?<a>y)|z){2}",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "Group",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "(?:(?<a>x)|(?<a>y)|z)",
+                    "modifiers": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 12,
+                        "raw": "(?<a>x)",
+                        "elements": [
+                          {
+                            "type": "CapturingGroup",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 12,
+                            "raw": "(?<a>x)",
+                            "name": "a",
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "x",
+                                "elements": [
+                                  {
+                                    "type": "Character",
+                                    "parent": "♻️../..",
+                                    "start": 10,
+                                    "end": 11,
+                                    "raw": "x",
+                                    "value": 120
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": [
+                              "♻️../../../../../../2"
+                            ]
+                          }
+                        ]
+                      },
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 13,
+                        "end": 20,
+                        "raw": "(?<a>y)",
+                        "elements": [
+                          {
+                            "type": "CapturingGroup",
+                            "parent": "♻️../..",
+                            "start": 13,
+                            "end": 20,
+                            "raw": "(?<a>y)",
+                            "name": "a",
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 18,
+                                "end": 19,
+                                "raw": "y",
+                                "elements": [
+                                  {
+                                    "type": "Character",
+                                    "parent": "♻️../..",
+                                    "start": 18,
+                                    "end": 19,
+                                    "raw": "y",
+                                    "value": 121
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": [
+                              "♻️../../../../../../2"
+                            ]
+                          }
+                        ]
+                      },
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 21,
+                        "end": 22,
+                        "raw": "z",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 21,
+                            "end": 22,
+                            "raw": "z",
+                            "value": 122
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 31,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": true,
+                  "resolved": [
+                    "♻️../1/element/alternatives/0/elements/0",
+                    "♻️../1/element/alternatives/1/elements/0"
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 33,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/regexp-lookbehind-and-regexp-named-groups.json b/test/fixtures/parser/literal/test262/regexp-lookbehind-and-regexp-named-groups.json
new file mode 100644
index 0000000..b5ff010
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/regexp-lookbehind-and-regexp-named-groups.json
@@ -0,0 +1,1439 @@
+{
+  "_test262FileNames": [
+    "test/annexB/built-ins/RegExp/named-groups/non-unicode-malformed-lookbehind.js",
+    "test/built-ins/RegExp/named-groups/lookbehind.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/(?<!(?<a>\\D){3})f/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?<!(?<a>\\D){3})f/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "(?<!(?<a>\\D){3})f",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?<!(?<a>\\D){3})f",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 17,
+                  "raw": "(?<!(?<a>\\D){3})",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 16,
+                      "raw": "(?<a>\\D){3}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 16,
+                          "raw": "(?<a>\\D){3}",
+                          "min": 3,
+                          "max": 3,
+                          "greedy": true,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 13,
+                            "raw": "(?<a>\\D)",
+                            "name": "a",
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 12,
+                                "raw": "\\D",
+                                "elements": [
+                                  {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️../..",
+                                    "start": 10,
+                                    "end": 12,
+                                    "raw": "\\D",
+                                    "kind": "digit",
+                                    "negate": true
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 19,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!(?<a>\\D){3})f/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(?<!(?<a>\\D){3})f/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "(?<!(?<a>\\D){3})f",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?<!(?<a>\\D){3})f",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 17,
+                  "raw": "(?<!(?<a>\\D){3})",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 16,
+                      "raw": "(?<a>\\D){3}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 16,
+                          "raw": "(?<a>\\D){3}",
+                          "min": 3,
+                          "max": 3,
+                          "greedy": true,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 13,
+                            "raw": "(?<a>\\D)",
+                            "name": "a",
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 12,
+                                "raw": "\\D",
+                                "elements": [
+                                  {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️../..",
+                                    "start": 10,
+                                    "end": 12,
+                                    "raw": "\\D",
+                                    "kind": "digit",
+                                    "negate": true
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!(?<a>\\D){3})f|f/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?<!(?<a>\\D){3})f|f/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?<!(?<a>\\D){3})f|f",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?<!(?<a>\\D){3})f",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 17,
+                  "raw": "(?<!(?<a>\\D){3})",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 16,
+                      "raw": "(?<a>\\D){3}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 16,
+                          "raw": "(?<a>\\D){3}",
+                          "min": 3,
+                          "max": 3,
+                          "greedy": true,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 13,
+                            "raw": "(?<a>\\D)",
+                            "name": "a",
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 12,
+                                "raw": "\\D",
+                                "elements": [
+                                  {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️../..",
+                                    "start": 10,
+                                    "end": 12,
+                                    "raw": "\\D",
+                                    "kind": "digit",
+                                    "negate": true
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 19,
+              "end": 20,
+              "raw": "f",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!a>)\\k<a>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?<!a>)\\k<a>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<!a>)\\k<a>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<!a>)\\k<a>",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<!a>)",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "a>",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ">",
+                          "value": 62
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 10,
+                  "raw": "\\k",
+                  "value": 107
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "<",
+                  "value": 60
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": ">",
+                  "value": 62
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(?<a>\\w)+)f/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<=(?<a>\\w)+)f/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<=(?<a>\\w)+)f",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<=(?<a>\\w)+)f",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<=(?<a>\\w)+)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 14,
+                      "raw": "(?<a>\\w)+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 14,
+                          "raw": "(?<a>\\w)+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 13,
+                            "raw": "(?<a>\\w)",
+                            "name": "a",
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 12,
+                                "raw": "\\w",
+                                "elements": [
+                                  {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️../..",
+                                    "start": 10,
+                                    "end": 12,
+                                    "raw": "\\w",
+                                    "kind": "word",
+                                    "negate": false
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(?<a>\\w)+)f/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?<=(?<a>\\w)+)f/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<=(?<a>\\w)+)f",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<=(?<a>\\w)+)f",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<=(?<a>\\w)+)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 14,
+                      "raw": "(?<a>\\w)+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 14,
+                          "raw": "(?<a>\\w)+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 13,
+                            "raw": "(?<a>\\w)",
+                            "name": "a",
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 12,
+                                "raw": "\\w",
+                                "elements": [
+                                  {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️../..",
+                                    "start": 10,
+                                    "end": 12,
+                                    "raw": "\\w",
+                                    "kind": "word",
+                                    "negate": false
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(?<a>\\w){4})f/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?<=(?<a>\\w){4})f/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "(?<=(?<a>\\w){4})f",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?<=(?<a>\\w){4})f",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 17,
+                  "raw": "(?<=(?<a>\\w){4})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 16,
+                      "raw": "(?<a>\\w){4}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 16,
+                          "raw": "(?<a>\\w){4}",
+                          "min": 4,
+                          "max": 4,
+                          "greedy": true,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 13,
+                            "raw": "(?<a>\\w)",
+                            "name": "a",
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 12,
+                                "raw": "\\w",
+                                "elements": [
+                                  {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️../..",
+                                    "start": 10,
+                                    "end": 12,
+                                    "raw": "\\w",
+                                    "kind": "word",
+                                    "negate": false
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 19,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(?<a>\\w){4})f/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(?<=(?<a>\\w){4})f/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "(?<=(?<a>\\w){4})f",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?<=(?<a>\\w){4})f",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 17,
+                  "raw": "(?<=(?<a>\\w){4})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 16,
+                      "raw": "(?<a>\\w){4}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 16,
+                          "raw": "(?<a>\\w){4}",
+                          "min": 4,
+                          "max": 4,
+                          "greedy": true,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 13,
+                            "raw": "(?<a>\\w)",
+                            "name": "a",
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 12,
+                                "raw": "\\w",
+                                "elements": [
+                                  {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️../..",
+                                    "start": 10,
+                                    "end": 12,
+                                    "raw": "\\w",
+                                    "kind": "word",
+                                    "negate": false
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(?<a>\\w){6})f/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?<=(?<a>\\w){6})f/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "(?<=(?<a>\\w){6})f",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?<=(?<a>\\w){6})f",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 17,
+                  "raw": "(?<=(?<a>\\w){6})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 16,
+                      "raw": "(?<a>\\w){6}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 16,
+                          "raw": "(?<a>\\w){6}",
+                          "min": 6,
+                          "max": 6,
+                          "greedy": true,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 13,
+                            "raw": "(?<a>\\w)",
+                            "name": "a",
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 12,
+                                "raw": "\\w",
+                                "elements": [
+                                  {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️../..",
+                                    "start": 10,
+                                    "end": 12,
+                                    "raw": "\\w",
+                                    "kind": "word",
+                                    "negate": false
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 19,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(?<a>\\w){6})f/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(?<=(?<a>\\w){6})f/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "(?<=(?<a>\\w){6})f",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?<=(?<a>\\w){6})f",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 17,
+                  "raw": "(?<=(?<a>\\w){6})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 16,
+                      "raw": "(?<a>\\w){6}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 16,
+                          "raw": "(?<a>\\w){6}",
+                          "min": 6,
+                          "max": 6,
+                          "greedy": true,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 13,
+                            "raw": "(?<a>\\w)",
+                            "name": "a",
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 12,
+                                "raw": "\\w",
+                                "elements": [
+                                  {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️../..",
+                                    "start": 10,
+                                    "end": 12,
+                                    "raw": "\\w",
+                                    "kind": "word",
+                                    "negate": false
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=>)\\k<a>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?<=>)\\k<a>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(?<=>)\\k<a>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(?<=>)\\k<a>",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?<=>)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": ">",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": ">",
+                          "value": 62
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 9,
+                  "raw": "\\k",
+                  "value": 107
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "<",
+                  "value": 60
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": ">",
+                  "value": 62
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\k<a>(?<!a)a/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/\\k<a>(?<!a)a/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "\\k<a>(?<!a)a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "\\k<a>(?<!a)a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\k",
+                  "value": 107
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "<",
+                  "value": 60
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ">",
+                  "value": 62
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 12,
+                  "raw": "(?<!a)",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 11,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\k<a>(?<=>)a/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/\\k<a>(?<=>)a/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "\\k<a>(?<=>)a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "\\k<a>(?<=>)a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\k",
+                  "value": 107
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "<",
+                  "value": 60
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ">",
+                  "value": 62
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 12,
+                  "raw": "(?<=>)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 11,
+                      "raw": ">",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": ">",
+                          "value": 62
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/regexp-lookbehind.json b/test/fixtures/parser/literal/test262/regexp-lookbehind.json
new file mode 100644
index 0000000..5b40f2d
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/regexp-lookbehind.json
@@ -0,0 +1,13740 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/lookBehind/alternations.js",
+    "test/built-ins/RegExp/lookBehind/back-references-to-captures.js",
+    "test/built-ins/RegExp/lookBehind/back-references.js",
+    "test/built-ins/RegExp/lookBehind/captures-negative.js",
+    "test/built-ins/RegExp/lookBehind/captures.js",
+    "test/built-ins/RegExp/lookBehind/do-not-backtrack.js",
+    "test/built-ins/RegExp/lookBehind/greedy-loop.js",
+    "test/built-ins/RegExp/lookBehind/misc.js",
+    "test/built-ins/RegExp/lookBehind/mutual-recursive.js",
+    "test/built-ins/RegExp/lookBehind/negative.js",
+    "test/built-ins/RegExp/lookBehind/nested-lookaround.js",
+    "test/built-ins/RegExp/lookBehind/simple-fixed-length.js",
+    "test/built-ins/RegExp/lookBehind/sliced-strings.js",
+    "test/built-ins/RegExp/lookBehind/start-of-line.js",
+    "test/built-ins/RegExp/lookBehind/sticky.js",
+    "test/built-ins/RegExp/lookBehind/variable-length.js",
+    "test/built-ins/RegExp/lookBehind/word-boundary.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/\"^foooo(?<=^o*)$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/\"^foooo(?<=^o*)$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "\"^foooo(?<=^o*)$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "\"^foooo(?<=^o*)$",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "\"",
+                  "value": 34
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 16,
+                  "raw": "(?<=^o*)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 15,
+                      "raw": "^o*",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 15,
+                          "raw": "o*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 13,
+                            "end": 14,
+                            "raw": "o",
+                            "value": 111
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 18,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\"^foooo(?<=^o+)$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/\"^foooo(?<=^o+)$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "\"^foooo(?<=^o+)$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "\"^foooo(?<=^o+)$",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "\"",
+                  "value": 34
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 16,
+                  "raw": "(?<=^o+)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 15,
+                      "raw": "^o+",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 15,
+                          "raw": "o+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 13,
+                            "end": 14,
+                            "raw": "o",
+                            "value": 111
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 18,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/((\\w)\\w)(?<=\\1\\2\\1)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/((\\w)\\w)(?<=\\1\\2\\1)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "((\\w)\\w)(?<=\\1\\2\\1)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "((\\w)\\w)(?<=\\1\\2\\1)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "((\\w)\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "(\\w)\\w",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 6,
+                          "raw": "(\\w)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 3,
+                              "end": 5,
+                              "raw": "\\w",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 3,
+                                  "end": 5,
+                                  "raw": "\\w",
+                                  "kind": "word",
+                                  "negate": false
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../1/alternatives/0/elements/1"
+                          ]
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1/alternatives/0/elements/0",
+                    "♻️../1/alternatives/0/elements/2"
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 20,
+                  "raw": "(?<=\\1\\2\\1)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 19,
+                      "raw": "\\1\\2\\1",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 15,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 17,
+                          "raw": "\\2",
+                          "ref": 2,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0/alternatives/0/elements/0"
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 19,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.)(?<=(\\1\\1))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(.)(?<=(\\1\\1))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(.)(?<=(\\1\\1))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(.)(?<=(\\1\\1))",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1/alternatives/0/elements/0/alternatives/0/elements/0",
+                    "♻️../1/alternatives/0/elements/0/alternatives/0/elements/1"
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 15,
+                  "raw": "(?<=(\\1\\1))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 14,
+                      "raw": "(\\1\\1)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 14,
+                          "raw": "(\\1\\1)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 13,
+                              "raw": "\\1\\1",
+                              "elements": [
+                                {
+                                  "type": "Backreference",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 11,
+                                  "raw": "\\1",
+                                  "ref": 1,
+                                  "ambiguous": false,
+                                  "resolved": "♻️../../../../../../../../../0"
+                                },
+                                {
+                                  "type": "Backreference",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 13,
+                                  "raw": "\\1",
+                                  "ref": 1,
+                                  "ambiguous": false,
+                                  "resolved": "♻️../../../../../../../../../0"
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.)(?<=(\\1\\1))/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(.)(?<=(\\1\\1))/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(.)(?<=(\\1\\1))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(.)(?<=(\\1\\1))",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1/alternatives/0/elements/0/alternatives/0/elements/0",
+                    "♻️../1/alternatives/0/elements/0/alternatives/0/elements/1"
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 15,
+                  "raw": "(?<=(\\1\\1))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 14,
+                      "raw": "(\\1\\1)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 14,
+                          "raw": "(\\1\\1)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 13,
+                              "raw": "\\1\\1",
+                              "elements": [
+                                {
+                                  "type": "Backreference",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 11,
+                                  "raw": "\\1",
+                                  "ref": 1,
+                                  "ambiguous": false,
+                                  "resolved": "♻️../../../../../../../../../0"
+                                },
+                                {
+                                  "type": "Backreference",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 13,
+                                  "raw": "\\1",
+                                  "ref": 1,
+                                  "ambiguous": false,
+                                  "resolved": "♻️../../../../../../../../../0"
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.)(?<=\\1\\1\\1)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(.)(?<=\\1\\1\\1)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(.)(?<=\\1\\1\\1)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(.)(?<=\\1\\1\\1)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1/alternatives/0/elements/0",
+                    "♻️../1/alternatives/0/elements/1",
+                    "♻️../1/alternatives/0/elements/2"
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 15,
+                  "raw": "(?<=\\1\\1\\1)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 14,
+                      "raw": "\\1\\1\\1",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 10,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 12,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 14,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(..)(?<=\\1\\1\\1)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(..)(?<=\\1\\1\\1)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(..)(?<=\\1\\1\\1)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(..)(?<=\\1\\1\\1)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 5,
+                  "raw": "(..)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 4,
+                      "raw": "..",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1/alternatives/0/elements/0",
+                    "♻️../1/alternatives/0/elements/1",
+                    "♻️../1/alternatives/0/elements/2"
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 16,
+                  "raw": "(?<=\\1\\1\\1)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 15,
+                      "raw": "\\1\\1\\1",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 11,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 13,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 15,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!(^|[ab]))\\w{2}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(?<!(^|[ab]))\\w{2}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?<!(^|[ab]))\\w{2}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?<!(^|[ab]))\\w{2}",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<!(^|[ab]))",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 13,
+                      "raw": "(^|[ab])",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 13,
+                          "raw": "(^|[ab])",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "^",
+                              "elements": [
+                                {
+                                  "type": "Assertion",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 7,
+                                  "raw": "^",
+                                  "kind": "start"
+                                }
+                              ]
+                            },
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 12,
+                              "raw": "[ab]",
+                              "elements": [
+                                {
+                                  "type": "CharacterClass",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 12,
+                                  "raw": "[ab]",
+                                  "unicodeSets": false,
+                                  "negate": false,
+                                  "elements": [
+                                    {
+                                      "type": "Character",
+                                      "parent": "♻️../..",
+                                      "start": 9,
+                                      "end": 10,
+                                      "raw": "a",
+                                      "value": 97
+                                    },
+                                    {
+                                      "type": "Character",
+                                      "parent": "♻️../..",
+                                      "start": 10,
+                                      "end": 11,
+                                      "raw": "b",
+                                      "value": 98
+                                    }
+                                  ]
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 19,
+                  "raw": "\\w{2}",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 14,
+                    "end": 16,
+                    "raw": "\\w",
+                    "kind": "word",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 20,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!a.c)\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(?<!a.c)\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(?<!a.c)\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?<!a.c)\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<!a.c)",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "a.c",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 13,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 15,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!a.c)def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?<!a.c)def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(?<!a.c)def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(?<!a.c)def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<!a.c)",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "a.c",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!a[a-z])\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?<!a[a-z])\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "(?<!a[a-z])\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?<!a[a-z])\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "(?<!a[a-z])",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 11,
+                      "raw": "a[a-z]",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 11,
+                          "raw": "[a-z]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "CharacterClassRange",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 10,
+                              "raw": "a-z",
+                              "min": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 7,
+                                "end": 8,
+                                "raw": "a",
+                                "value": 97
+                              },
+                              "max": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 9,
+                                "end": 10,
+                                "raw": "z",
+                                "value": 122
+                              }
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 14,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 16,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 18,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 19,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!a[a-z][a-z])def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?<!a[a-z][a-z])def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?<!a[a-z][a-z])def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(?<!a[a-z][a-z])def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 17,
+                  "raw": "(?<!a[a-z][a-z])",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 16,
+                      "raw": "a[a-z][a-z]",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 11,
+                          "raw": "[a-z]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "CharacterClassRange",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 10,
+                              "raw": "a-z",
+                              "min": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 7,
+                                "end": 8,
+                                "raw": "a",
+                                "value": 97
+                              },
+                              "max": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 9,
+                                "end": 10,
+                                "raw": "z",
+                                "value": 122
+                              }
+                            }
+                          ]
+                        },
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 16,
+                          "raw": "[a-z]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "CharacterClassRange",
+                              "parent": "♻️../..",
+                              "start": 12,
+                              "end": 15,
+                              "raw": "a-z",
+                              "min": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "a",
+                                "value": 97
+                              },
+                              "max": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 14,
+                                "end": 15,
+                                "raw": "z",
+                                "value": 122
+                              }
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!a[a-z]{2})\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(?<!a[a-z]{2})\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "(?<!a[a-z]{2})\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "(?<!a[a-z]{2})\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<!a[a-z]{2})",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 14,
+                      "raw": "a[a-z]{2}",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 14,
+                          "raw": "[a-z]{2}",
+                          "min": 2,
+                          "max": 2,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 11,
+                            "raw": "[a-z]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterClassRange",
+                                "parent": "♻️../..",
+                                "start": 7,
+                                "end": 10,
+                                "raw": "a-z",
+                                "min": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                "max": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "z",
+                                  "value": 122
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 17,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 19,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 21,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 22,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!a[a-z]{2})def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?<!a[a-z]{2})def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "(?<!a[a-z]{2})def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?<!a[a-z]{2})def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<!a[a-z]{2})",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 14,
+                      "raw": "a[a-z]{2}",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 14,
+                          "raw": "[a-z]{2}",
+                          "min": 2,
+                          "max": 2,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 11,
+                            "raw": "[a-z]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterClassRange",
+                                "parent": "♻️../..",
+                                "start": 7,
+                                "end": 10,
+                                "raw": "a-z",
+                                "min": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                "max": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "z",
+                                  "value": 122
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 19,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!a\\wc)\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<!a\\wc)\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<!a\\wc)\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<!a\\wc)\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<!a\\wc)",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "a\\wc",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 12,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 14,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 16,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!a\\wc)def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?<!a\\wc)def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<!a\\wc)def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<!a\\wc)def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<!a\\wc)",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "a\\wc",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!abc)\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(?<!abc)\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(?<!abc)\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?<!abc)\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<!abc)",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "abc",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 13,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 15,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!abc)def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?<!abc)def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(?<!abc)def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(?<!abc)def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<!abc)",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "abc",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!a{1}[a-z]{2})def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(?<!a{1}[a-z]{2})def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "(?<!a{1}[a-z]{2})def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "(?<!a{1}[a-z]{2})def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 18,
+                  "raw": "(?<!a{1}[a-z]{2})",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 17,
+                      "raw": "a{1}[a-z]{2}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 9,
+                          "raw": "a{1}",
+                          "min": 1,
+                          "max": 1,
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "a",
+                            "value": 97
+                          }
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 17,
+                          "raw": "[a-z]{2}",
+                          "min": 2,
+                          "max": 2,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 14,
+                            "raw": "[a-z]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterClassRange",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 13,
+                                "raw": "a-z",
+                                "min": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 10,
+                                  "end": 11,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                "max": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": "z",
+                                  "value": 122
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 22,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<!a{1}b{1})cde/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?<!a{1}b{1})cde/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "(?<!a{1}b{1})cde",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "(?<!a{1}b{1})cde",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<!a{1}b{1})",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 13,
+                      "raw": "a{1}b{1}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 9,
+                          "raw": "a{1}",
+                          "min": 1,
+                          "max": 1,
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "a",
+                            "value": 97
+                          }
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 13,
+                          "raw": "b{1}",
+                          "min": 1,
+                          "max": 1,
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "b",
+                            "value": 98
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "c",
+                  "value": 99
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "e",
+                  "value": 101
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 18,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=$abc)def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?<=$abc)def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<=$abc)def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<=$abc)def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<=$abc)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "$abc",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "$",
+                          "kind": "end"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=((?:b\\d{2})+))c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?<=((?:b\\d{2})+))c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?<=((?:b\\d{2})+))c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(?<=((?:b\\d{2})+))c",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 19,
+                  "raw": "(?<=((?:b\\d{2})+))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 18,
+                      "raw": "((?:b\\d{2})+)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 18,
+                          "raw": "((?:b\\d{2})+)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 17,
+                              "raw": "(?:b\\d{2})+",
+                              "elements": [
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 17,
+                                  "raw": "(?:b\\d{2})+",
+                                  "min": 1,
+                                  "max": "$$Infinity",
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "Group",
+                                    "parent": "♻️..",
+                                    "start": 6,
+                                    "end": 16,
+                                    "raw": "(?:b\\d{2})",
+                                    "modifiers": null,
+                                    "alternatives": [
+                                      {
+                                        "type": "Alternative",
+                                        "parent": "♻️../..",
+                                        "start": 9,
+                                        "end": 15,
+                                        "raw": "b\\d{2}",
+                                        "elements": [
+                                          {
+                                            "type": "Character",
+                                            "parent": "♻️../..",
+                                            "start": 9,
+                                            "end": 10,
+                                            "raw": "b",
+                                            "value": 98
+                                          },
+                                          {
+                                            "type": "Quantifier",
+                                            "parent": "♻️../..",
+                                            "start": 10,
+                                            "end": 15,
+                                            "raw": "\\d{2}",
+                                            "min": 2,
+                                            "max": 2,
+                                            "greedy": true,
+                                            "element": {
+                                              "type": "CharacterSet",
+                                              "parent": "♻️..",
+                                              "start": 10,
+                                              "end": 12,
+                                              "raw": "\\d",
+                                              "kind": "digit",
+                                              "negate": false
+                                            }
+                                          }
+                                        ]
+                                      }
+                                    ]
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(.))(\\w+)(?=\\1)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?<=(.))(\\w+)(?=\\1)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?<=(.))(\\w+)(?=\\1)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(?<=(.))(\\w+)(?=\\1)",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<=(.))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "(.)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 8,
+                          "raw": "(.)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": ".",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 7,
+                                  "raw": ".",
+                                  "kind": "any"
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../2/alternatives/0/elements/0"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 14,
+                  "raw": "(\\w+)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 13,
+                      "raw": "\\w+",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 13,
+                          "raw": "\\w+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 10,
+                            "end": 12,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 20,
+                  "raw": "(?=\\1)",
+                  "kind": "lookahead",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 17,
+                      "end": 19,
+                      "raw": "\\1",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 19,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0/alternatives/0/elements/0"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(?:\\1b)(aa))./": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?<=(?:\\1b)(aa))./",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "(?<=(?:\\1b)(aa)).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?<=(?:\\1b)(aa)).",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 17,
+                  "raw": "(?<=(?:\\1b)(aa))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 16,
+                      "raw": "(?:\\1b)(aa)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 12,
+                          "raw": "(?:\\1b)",
+                          "modifiers": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 11,
+                              "raw": "\\1b",
+                              "elements": [
+                                {
+                                  "type": "Backreference",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 10,
+                                  "raw": "\\1",
+                                  "ref": 1,
+                                  "ambiguous": false,
+                                  "resolved": "♻️../../../../../1"
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 10,
+                                  "end": 11,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 16,
+                          "raw": "(aa)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 13,
+                              "end": 15,
+                              "raw": "aa",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 14,
+                                  "end": 15,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../0/alternatives/0/elements/0"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 19,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(?:\\1|b)(aa))./": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(?<=(?:\\1|b)(aa))./",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?<=(?:\\1|b)(aa)).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?<=(?:\\1|b)(aa)).",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 18,
+                  "raw": "(?<=(?:\\1|b)(aa))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 17,
+                      "raw": "(?:\\1|b)(aa)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 13,
+                          "raw": "(?:\\1|b)",
+                          "modifiers": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 10,
+                              "raw": "\\1",
+                              "elements": [
+                                {
+                                  "type": "Backreference",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 10,
+                                  "raw": "\\1",
+                                  "ref": 1,
+                                  "ambiguous": false,
+                                  "resolved": "♻️../../../../../1"
+                                }
+                              ]
+                            },
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "b",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 17,
+                          "raw": "(aa)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 14,
+                              "end": 16,
+                              "raw": "aa",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 14,
+                                  "end": 15,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 15,
+                                  "end": 16,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../0/alternatives/0/elements/0"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 20,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=([ab]{1,2})\\D|(abc))\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/(?<=([ab]{1,2})\\D|(abc))\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "(?<=([ab]{1,2})\\D|(abc))\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "(?<=([ab]{1,2})\\D|(abc))\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 25,
+                  "raw": "(?<=([ab]{1,2})\\D|(abc))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 18,
+                      "raw": "([ab]{1,2})\\D",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 16,
+                          "raw": "([ab]{1,2})",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 15,
+                              "raw": "[ab]{1,2}",
+                              "elements": [
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 15,
+                                  "raw": "[ab]{1,2}",
+                                  "min": 1,
+                                  "max": 2,
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "CharacterClass",
+                                    "parent": "♻️..",
+                                    "start": 6,
+                                    "end": 10,
+                                    "raw": "[ab]",
+                                    "unicodeSets": false,
+                                    "negate": false,
+                                    "elements": [
+                                      {
+                                        "type": "Character",
+                                        "parent": "♻️../..",
+                                        "start": 7,
+                                        "end": 8,
+                                        "raw": "a",
+                                        "value": 97
+                                      },
+                                      {
+                                        "type": "Character",
+                                        "parent": "♻️../..",
+                                        "start": 8,
+                                        "end": 9,
+                                        "raw": "b",
+                                        "value": 98
+                                      }
+                                    ]
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 18,
+                          "raw": "\\D",
+                          "kind": "digit",
+                          "negate": true
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 19,
+                      "end": 24,
+                      "raw": "(abc)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 24,
+                          "raw": "(abc)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 20,
+                              "end": 23,
+                              "raw": "abc",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 20,
+                                  "end": 21,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 21,
+                                  "end": 22,
+                                  "raw": "b",
+                                  "value": 98
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 22,
+                                  "end": 23,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 27,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 28,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=([abc]+)).\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?<=([abc]+)).\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "(?<=([abc]+)).\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "(?<=([abc]+)).\\1",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<=([abc]+))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 13,
+                      "raw": "([abc]+)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 13,
+                          "raw": "([abc]+)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 12,
+                              "raw": "[abc]+",
+                              "elements": [
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 12,
+                                  "raw": "[abc]+",
+                                  "min": 1,
+                                  "max": "$$Infinity",
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "CharacterClass",
+                                    "parent": "♻️..",
+                                    "start": 6,
+                                    "end": 11,
+                                    "raw": "[abc]",
+                                    "unicodeSets": false,
+                                    "negate": false,
+                                    "elements": [
+                                      {
+                                        "type": "Character",
+                                        "parent": "♻️../..",
+                                        "start": 7,
+                                        "end": 8,
+                                        "raw": "a",
+                                        "value": 97
+                                      },
+                                      {
+                                        "type": "Character",
+                                        "parent": "♻️../..",
+                                        "start": 8,
+                                        "end": 9,
+                                        "raw": "b",
+                                        "value": 98
+                                      },
+                                      {
+                                        "type": "Character",
+                                        "parent": "♻️../..",
+                                        "start": 9,
+                                        "end": 10,
+                                        "raw": "c",
+                                        "value": 99
+                                      }
+                                    ]
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../2"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 17,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0/alternatives/0/elements/0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 18,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(\\w(\\w)))def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?<=(\\w(\\w)))def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "(?<=(\\w(\\w)))def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "(?<=(\\w(\\w)))def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<=(\\w(\\w)))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 13,
+                      "raw": "(\\w(\\w))",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 13,
+                          "raw": "(\\w(\\w))",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 12,
+                              "raw": "\\w(\\w)",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 8,
+                                  "raw": "\\w",
+                                  "kind": "word",
+                                  "negate": false
+                                },
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 12,
+                                  "raw": "(\\w)",
+                                  "name": null,
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 9,
+                                      "end": 11,
+                                      "raw": "\\w",
+                                      "elements": [
+                                        {
+                                          "type": "CharacterSet",
+                                          "parent": "♻️../..",
+                                          "start": 9,
+                                          "end": 11,
+                                          "raw": "\\w",
+                                          "kind": "word",
+                                          "negate": false
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": []
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 18,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(\\w){3})def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<=(\\w){3})def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<=(\\w){3})def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<=(\\w){3})def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?<=(\\w){3})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 12,
+                      "raw": "(\\w){3}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 12,
+                          "raw": "(\\w){3}",
+                          "min": 3,
+                          "max": 3,
+                          "greedy": true,
+                          "element": {
+                            "type": "CapturingGroup",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 9,
+                            "raw": "(\\w)",
+                            "name": null,
+                            "alternatives": [
+                              {
+                                "type": "Alternative",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 8,
+                                "raw": "\\w",
+                                "elements": [
+                                  {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️../..",
+                                    "start": 6,
+                                    "end": 8,
+                                    "raw": "\\w",
+                                    "kind": "word",
+                                    "negate": false
+                                  }
+                                ]
+                              }
+                            ],
+                            "references": []
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(\\w+)\\1)c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?<=(\\w+)\\1)c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?<=(\\w+)\\1)c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?<=(\\w+)\\1)c",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?<=(\\w+)\\1)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 12,
+                      "raw": "(\\w+)\\1",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 10,
+                          "raw": "(\\w+)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 9,
+                              "raw": "\\w+",
+                              "elements": [
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 9,
+                                  "raw": "\\w+",
+                                  "min": 1,
+                                  "max": "$$Infinity",
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️..",
+                                    "start": 6,
+                                    "end": 8,
+                                    "raw": "\\w",
+                                    "kind": "word",
+                                    "negate": false
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../1"
+                          ]
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 12,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../0"
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(\\w{2}))def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<=(\\w{2}))def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<=(\\w{2}))def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<=(\\w{2}))def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?<=(\\w{2}))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 12,
+                      "raw": "(\\w{2})",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 12,
+                          "raw": "(\\w{2})",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 11,
+                              "raw": "\\w{2}",
+                              "elements": [
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 11,
+                                  "raw": "\\w{2}",
+                                  "min": 2,
+                                  "max": 2,
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️..",
+                                    "start": 6,
+                                    "end": 8,
+                                    "raw": "\\w",
+                                    "kind": "word",
+                                    "negate": false
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(b+))c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?<=(b+))c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?<=(b+))c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?<=(b+))c",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<=(b+))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "(b+)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 9,
+                          "raw": "(b+)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 8,
+                              "raw": "b+",
+                              "elements": [
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 8,
+                                  "raw": "b+",
+                                  "min": 1,
+                                  "max": "$$Infinity",
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "Character",
+                                    "parent": "♻️..",
+                                    "start": 6,
+                                    "end": 7,
+                                    "raw": "b",
+                                    "value": 98
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(b\\d+))c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?<=(b\\d+))c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<=(b\\d+))c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<=(b\\d+))c",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "(?<=(b\\d+))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 11,
+                      "raw": "(b\\d+)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 11,
+                          "raw": "(b\\d+)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 10,
+                              "raw": "b\\d+",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 7,
+                                  "raw": "b",
+                                  "value": 98
+                                },
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 10,
+                                  "raw": "\\d+",
+                                  "min": 1,
+                                  "max": "$$Infinity",
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️..",
+                                    "start": 7,
+                                    "end": 9,
+                                    "raw": "\\d",
+                                    "kind": "digit",
+                                    "negate": false
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(bc)|(cd))./": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<=(bc)|(cd))./",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<=(bc)|(cd)).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<=(bc)|(cd)).",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<=(bc)|(cd))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "(bc)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 9,
+                          "raw": "(bc)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 8,
+                              "raw": "bc",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 7,
+                                  "raw": "b",
+                                  "value": 98
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 14,
+                      "raw": "(cd)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 14,
+                          "raw": "(cd)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 13,
+                              "raw": "cd",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "c",
+                                  "value": 99
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": "d",
+                                  "value": 100
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=(c))def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?<=(c))def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(?<=(c))def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(?<=(c))def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<=(c))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "(c)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 8,
+                          "raw": "(c)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "c",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 7,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=[a|b|c]*)[^a|b|c]{3}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/(?<=[a|b|c]*)[^a|b|c]{3}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "(?<=[a|b|c]*)[^a|b|c]{3}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "(?<=[a|b|c]*)[^a|b|c]{3}",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<=[a|b|c]*)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 13,
+                      "raw": "[a|b|c]*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 13,
+                          "raw": "[a|b|c]*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 12,
+                            "raw": "[a|b|c]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "a",
+                                "value": 97
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 7,
+                                "end": 8,
+                                "raw": "|",
+                                "value": 124
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "b",
+                                "value": 98
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 9,
+                                "end": 10,
+                                "raw": "|",
+                                "value": 124
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "c",
+                                "value": 99
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 25,
+                  "raw": "[^a|b|c]{3}",
+                  "min": 3,
+                  "max": 3,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 14,
+                    "end": 22,
+                    "raw": "[^a|b|c]",
+                    "unicodeSets": false,
+                    "negate": true,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 16,
+                        "end": 17,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 17,
+                        "end": 18,
+                        "raw": "|",
+                        "value": 124
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 18,
+                        "end": 19,
+                        "raw": "b",
+                        "value": 98
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 19,
+                        "end": 20,
+                        "raw": "|",
+                        "value": 124
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 20,
+                        "end": 21,
+                        "raw": "c",
+                        "value": 99
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 26,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=[b-e])\\w{2}/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?<=[b-e])\\w{2}/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<=[b-e])\\w{2}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<=[b-e])\\w{2}",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?<=[b-e])",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 10,
+                      "raw": "[b-e]",
+                      "elements": [
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 10,
+                          "raw": "[b-e]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "CharacterClassRange",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 9,
+                              "raw": "b-e",
+                              "min": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "b",
+                                "value": 98
+                              },
+                              "max": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "e",
+                                "value": 101
+                              }
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 16,
+                  "raw": "\\w{2}",
+                  "min": 2,
+                  "max": 2,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 11,
+                    "end": 13,
+                    "raw": "\\w",
+                    "kind": "word",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=\\1([abx]))d/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<=\\1([abx]))d/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<=\\1([abx]))d",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<=\\1([abx]))d",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<=\\1([abx]))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 14,
+                      "raw": "\\1([abx])",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../1"
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 14,
+                          "raw": "([abx])",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 13,
+                              "raw": "[abx]",
+                              "elements": [
+                                {
+                                  "type": "CharacterClass",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 13,
+                                  "raw": "[abx]",
+                                  "unicodeSets": false,
+                                  "negate": false,
+                                  "elements": [
+                                    {
+                                      "type": "Character",
+                                      "parent": "♻️../..",
+                                      "start": 9,
+                                      "end": 10,
+                                      "raw": "a",
+                                      "value": 97
+                                    },
+                                    {
+                                      "type": "Character",
+                                      "parent": "♻️../..",
+                                      "start": 10,
+                                      "end": 11,
+                                      "raw": "b",
+                                      "value": 98
+                                    },
+                                    {
+                                      "type": "Character",
+                                      "parent": "♻️../..",
+                                      "start": 11,
+                                      "end": 12,
+                                      "raw": "x",
+                                      "value": 120
+                                    }
+                                  ]
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../0"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=\\1(\\w))d/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?<=\\1(\\w))d/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<=\\1(\\w))d",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<=\\1(\\w))d",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "(?<=\\1(\\w))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 11,
+                      "raw": "\\1(\\w)",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../1"
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 11,
+                          "raw": "(\\w)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 10,
+                              "raw": "\\w",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 10,
+                                  "raw": "\\w",
+                                  "kind": "word",
+                                  "negate": false
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../0"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "d",
+                  "value": 100
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=\\1(\\w+))c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?<=\\1(\\w+))c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?<=\\1(\\w+))c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?<=\\1(\\w+))c",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?<=\\1(\\w+))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 12,
+                      "raw": "\\1(\\w+)",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../1"
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 12,
+                          "raw": "(\\w+)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 11,
+                              "raw": "\\w+",
+                              "elements": [
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 11,
+                                  "raw": "\\w+",
+                                  "min": 1,
+                                  "max": "$$Infinity",
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️..",
+                                    "start": 8,
+                                    "end": 10,
+                                    "raw": "\\w",
+                                    "kind": "word",
+                                    "negate": false
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../0"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=\\B)(?<=c(?<=\\w))\\w{3}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/(?<=\\B)(?<=c(?<=\\w))\\w{3}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "(?<=\\B)(?<=c(?<=\\w))\\w{3}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "(?<=\\B)(?<=c(?<=\\w))\\w{3}",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<=\\B)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "\\B",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\B",
+                          "kind": "word",
+                          "negate": true
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 21,
+                  "raw": "(?<=c(?<=\\w))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 20,
+                      "raw": "c(?<=\\w)",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "c",
+                          "value": 99
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 20,
+                          "raw": "(?<=\\w)",
+                          "kind": "lookbehind",
+                          "negate": false,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 17,
+                              "end": 19,
+                              "raw": "\\w",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 17,
+                                  "end": 19,
+                                  "raw": "\\w",
+                                  "kind": "word",
+                                  "negate": false
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 26,
+                  "raw": "\\w{3}",
+                  "min": 3,
+                  "max": 3,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 21,
+                    "end": 23,
+                    "raw": "\\w",
+                    "kind": "word",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 27,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=\\B)\\w{3}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?<=\\B)\\w{3}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<=\\B)\\w{3}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<=\\B)\\w{3}",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<=\\B)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "\\B",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\B",
+                          "kind": "word",
+                          "negate": true
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 13,
+                  "raw": "\\w{3}",
+                  "min": 3,
+                  "max": 3,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 8,
+                    "end": 10,
+                    "raw": "\\w",
+                    "kind": "word",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=\\b)[d-f]{3}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<=\\b)[d-f]{3}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<=\\b)[d-f]{3}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<=\\b)[d-f]{3}",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<=\\b)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "\\b",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\b",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 16,
+                  "raw": "[d-f]{3}",
+                  "min": 3,
+                  "max": 3,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 8,
+                    "end": 13,
+                    "raw": "[d-f]",
+                    "unicodeSets": false,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClassRange",
+                        "parent": "♻️../..",
+                        "start": 9,
+                        "end": 12,
+                        "raw": "d-f",
+                        "min": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        "max": {
+                          "type": "Character",
+                          "parent": "♻️..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "f",
+                          "value": 102
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=\\w*)[^a|b|c]{3}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?<=\\w*)[^a|b|c]{3}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?<=\\w*)[^a|b|c]{3}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(?<=\\w*)[^a|b|c]{3}",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<=\\w*)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "\\w*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 8,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 7,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 20,
+                  "raw": "[^a|b|c]{3}",
+                  "min": 3,
+                  "max": 3,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 9,
+                    "end": 17,
+                    "raw": "[^a|b|c]",
+                    "unicodeSets": false,
+                    "negate": true,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 11,
+                        "end": 12,
+                        "raw": "a",
+                        "value": 97
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 12,
+                        "end": 13,
+                        "raw": "|",
+                        "value": 124
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 13,
+                        "end": 14,
+                        "raw": "b",
+                        "value": 98
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 14,
+                        "end": 15,
+                        "raw": "|",
+                        "value": 124
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 15,
+                        "end": 16,
+                        "raw": "c",
+                        "value": 99
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=^(\\w+))def/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<=^(\\w+))def/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(?<=^(\\w+))def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?<=^(\\w+))def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "(?<=^(\\w+))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 11,
+                      "raw": "^(\\w+)",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 11,
+                          "raw": "(\\w+)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 10,
+                              "raw": "\\w+",
+                              "elements": [
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 10,
+                                  "raw": "\\w+",
+                                  "min": 1,
+                                  "max": "$$Infinity",
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "CharacterSet",
+                                    "parent": "♻️..",
+                                    "start": 7,
+                                    "end": 9,
+                                    "raw": "\\w",
+                                    "kind": "word",
+                                    "negate": false
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=^)\\w+(?<=$)/gm": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?<=^)\\w+(?<=$)/gm",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<=^)\\w+(?<=$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<=^)\\w+(?<=$)",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?<=^)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "^",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "^",
+                          "kind": "start"
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 10,
+                  "raw": "\\w+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 7,
+                    "end": 9,
+                    "raw": "\\w",
+                    "kind": "word",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 16,
+                  "raw": "(?<=$)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 15,
+                      "raw": "$",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 19,
+          "raw": "gm",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=^)\\w+/gm": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?<=^)\\w+/gm",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<=^)\\w+",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<=^)\\w+",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?<=^)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "^",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "^",
+                          "kind": "start"
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 10,
+                  "raw": "\\w+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 7,
+                    "end": 9,
+                    "raw": "\\w",
+                    "kind": "word",
+                    "negate": false
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 13,
+          "raw": "gm",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=^[^a-c]{3})def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(?<=^[^a-c]{3})def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?<=^[^a-c]{3})def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?<=^[^a-c]{3})def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 16,
+                  "raw": "(?<=^[^a-c]{3})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 15,
+                      "raw": "^[^a-c]{3}",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 15,
+                          "raw": "[^a-c]{3}",
+                          "min": 3,
+                          "max": 3,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 12,
+                            "raw": "[^a-c]",
+                            "unicodeSets": false,
+                            "negate": true,
+                            "elements": [
+                              {
+                                "type": "CharacterClassRange",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 11,
+                                "raw": "a-c",
+                                "min": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 8,
+                                  "end": 9,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                "max": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 10,
+                                  "end": 11,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 20,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=^[a-c]{3})def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?<=^[a-c]{3})def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "(?<=^[a-c]{3})def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?<=^[a-c]{3})def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<=^[a-c]{3})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 14,
+                      "raw": "^[a-c]{3}",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 14,
+                          "raw": "[a-c]{3}",
+                          "min": 3,
+                          "max": 3,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 11,
+                            "raw": "[a-c]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterClassRange",
+                                "parent": "♻️../..",
+                                "start": 7,
+                                "end": 10,
+                                "raw": "a-c",
+                                "min": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                "max": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 19,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=^[a-c]{3})def/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(?<=^[a-c]{3})def/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "(?<=^[a-c]{3})def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?<=^[a-c]{3})def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<=^[a-c]{3})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 14,
+                      "raw": "^[a-c]{3}",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 14,
+                          "raw": "[a-c]{3}",
+                          "min": 3,
+                          "max": 3,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 11,
+                            "raw": "[a-c]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterClassRange",
+                                "parent": "♻️../..",
+                                "start": 7,
+                                "end": 10,
+                                "raw": "a-c",
+                                "min": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                "max": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=^\\w+)def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?<=^\\w+)def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<=^\\w+)def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<=^\\w+)def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<=^\\w+)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "^\\w+",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 9,
+                          "raw": "\\w+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 8,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=^\\w+)def/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?<=^\\w+)def/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<=^\\w+)def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<=^\\w+)def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<=^\\w+)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "^\\w+",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 9,
+                          "raw": "\\w+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 8,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=^abc)def/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?<=^abc)def/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<=^abc)def",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<=^abc)def",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<=^abc)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "^abc",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=a(.\\2)b(\\1)).{4}/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(?<=a(.\\2)b(\\1)).{4}/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "(?<=a(.\\2)b(\\1)).{4}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "(?<=a(.\\2)b(\\1)).{4}",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 17,
+                  "raw": "(?<=a(.\\2)b(\\1))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 16,
+                      "raw": "a(.\\2)b(\\1)",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 11,
+                          "raw": "(.\\2)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 10,
+                              "raw": ".\\2",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "Backreference",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 10,
+                                  "raw": "\\2",
+                                  "ref": 2,
+                                  "ambiguous": false,
+                                  "resolved": "♻️../../../../../3"
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../3/alternatives/0/elements/0"
+                          ]
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 16,
+                          "raw": "(\\1)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 13,
+                              "end": 15,
+                              "raw": "\\1",
+                              "elements": [
+                                {
+                                  "type": "Backreference",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 15,
+                                  "raw": "\\1",
+                                  "ref": 1,
+                                  "ambiguous": false,
+                                  "resolved": "♻️../../../../../1"
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../1/alternatives/0/elements/1"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 21,
+                  "raw": ".{4}",
+                  "min": 4,
+                  "max": 4,
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 17,
+                    "end": 18,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 22,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=a(?=([^a]{2})d)\\w{3})\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/(?<=a(?=([^a]{2})d)\\w{3})\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "(?<=a(?=([^a]{2})d)\\w{3})\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "(?<=a(?=([^a]{2})d)\\w{3})\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 26,
+                  "raw": "(?<=a(?=([^a]{2})d)\\w{3})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 25,
+                      "raw": "a(?=([^a]{2})d)\\w{3}",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 20,
+                          "raw": "(?=([^a]{2})d)",
+                          "kind": "lookahead",
+                          "negate": false,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 19,
+                              "raw": "([^a]{2})d",
+                              "elements": [
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 18,
+                                  "raw": "([^a]{2})",
+                                  "name": null,
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 10,
+                                      "end": 17,
+                                      "raw": "[^a]{2}",
+                                      "elements": [
+                                        {
+                                          "type": "Quantifier",
+                                          "parent": "♻️../..",
+                                          "start": 10,
+                                          "end": 17,
+                                          "raw": "[^a]{2}",
+                                          "min": 2,
+                                          "max": 2,
+                                          "greedy": true,
+                                          "element": {
+                                            "type": "CharacterClass",
+                                            "parent": "♻️..",
+                                            "start": 10,
+                                            "end": 14,
+                                            "raw": "[^a]",
+                                            "unicodeSets": false,
+                                            "negate": true,
+                                            "elements": [
+                                              {
+                                                "type": "Character",
+                                                "parent": "♻️../..",
+                                                "start": 12,
+                                                "end": 13,
+                                                "raw": "a",
+                                                "value": 97
+                                              }
+                                            ]
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": []
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 18,
+                                  "end": 19,
+                                  "raw": "d",
+                                  "value": 100
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 25,
+                          "raw": "\\w{3}",
+                          "min": 3,
+                          "max": 3,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 20,
+                            "end": 22,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 28,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 30,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 31,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=a(?=([bc]{2}(?<!a*))d)\\w{3})\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/(?<=a(?=([bc]{2}(?<!a*))d)\\w{3})\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "(?<=a(?=([bc]{2}(?<!a*))d)\\w{3})\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "(?<=a(?=([bc]{2}(?<!a*))d)\\w{3})\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 33,
+                  "raw": "(?<=a(?=([bc]{2}(?<!a*))d)\\w{3})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 32,
+                      "raw": "a(?=([bc]{2}(?<!a*))d)\\w{3}",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 27,
+                          "raw": "(?=([bc]{2}(?<!a*))d)",
+                          "kind": "lookahead",
+                          "negate": false,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 26,
+                              "raw": "([bc]{2}(?<!a*))d",
+                              "elements": [
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 25,
+                                  "raw": "([bc]{2}(?<!a*))",
+                                  "name": null,
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 10,
+                                      "end": 24,
+                                      "raw": "[bc]{2}(?<!a*)",
+                                      "elements": [
+                                        {
+                                          "type": "Quantifier",
+                                          "parent": "♻️../..",
+                                          "start": 10,
+                                          "end": 17,
+                                          "raw": "[bc]{2}",
+                                          "min": 2,
+                                          "max": 2,
+                                          "greedy": true,
+                                          "element": {
+                                            "type": "CharacterClass",
+                                            "parent": "♻️..",
+                                            "start": 10,
+                                            "end": 14,
+                                            "raw": "[bc]",
+                                            "unicodeSets": false,
+                                            "negate": false,
+                                            "elements": [
+                                              {
+                                                "type": "Character",
+                                                "parent": "♻️../..",
+                                                "start": 11,
+                                                "end": 12,
+                                                "raw": "b",
+                                                "value": 98
+                                              },
+                                              {
+                                                "type": "Character",
+                                                "parent": "♻️../..",
+                                                "start": 12,
+                                                "end": 13,
+                                                "raw": "c",
+                                                "value": 99
+                                              }
+                                            ]
+                                          }
+                                        },
+                                        {
+                                          "type": "Assertion",
+                                          "parent": "♻️../..",
+                                          "start": 17,
+                                          "end": 24,
+                                          "raw": "(?<!a*)",
+                                          "kind": "lookbehind",
+                                          "negate": true,
+                                          "alternatives": [
+                                            {
+                                              "type": "Alternative",
+                                              "parent": "♻️../..",
+                                              "start": 21,
+                                              "end": 23,
+                                              "raw": "a*",
+                                              "elements": [
+                                                {
+                                                  "type": "Quantifier",
+                                                  "parent": "♻️../..",
+                                                  "start": 21,
+                                                  "end": 23,
+                                                  "raw": "a*",
+                                                  "min": 0,
+                                                  "max": "$$Infinity",
+                                                  "greedy": true,
+                                                  "element": {
+                                                    "type": "Character",
+                                                    "parent": "♻️..",
+                                                    "start": 21,
+                                                    "end": 22,
+                                                    "raw": "a",
+                                                    "value": 97
+                                                  }
+                                                }
+                                              ]
+                                            }
+                                          ]
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": []
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 25,
+                                  "end": 26,
+                                  "raw": "d",
+                                  "value": 100
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 27,
+                          "end": 32,
+                          "raw": "\\w{3}",
+                          "min": 3,
+                          "max": 3,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 27,
+                            "end": 29,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 35,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 37,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 38,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=a(?=([bc]{2}(?<!a{2}))d)\\w{3})\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/(?<=a(?=([bc]{2}(?<!a{2}))d)\\w{3})\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "(?<=a(?=([bc]{2}(?<!a{2}))d)\\w{3})\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "(?<=a(?=([bc]{2}(?<!a{2}))d)\\w{3})\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 35,
+                  "raw": "(?<=a(?=([bc]{2}(?<!a{2}))d)\\w{3})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 34,
+                      "raw": "a(?=([bc]{2}(?<!a{2}))d)\\w{3}",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 29,
+                          "raw": "(?=([bc]{2}(?<!a{2}))d)",
+                          "kind": "lookahead",
+                          "negate": false,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 28,
+                              "raw": "([bc]{2}(?<!a{2}))d",
+                              "elements": [
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 27,
+                                  "raw": "([bc]{2}(?<!a{2}))",
+                                  "name": null,
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 10,
+                                      "end": 26,
+                                      "raw": "[bc]{2}(?<!a{2})",
+                                      "elements": [
+                                        {
+                                          "type": "Quantifier",
+                                          "parent": "♻️../..",
+                                          "start": 10,
+                                          "end": 17,
+                                          "raw": "[bc]{2}",
+                                          "min": 2,
+                                          "max": 2,
+                                          "greedy": true,
+                                          "element": {
+                                            "type": "CharacterClass",
+                                            "parent": "♻️..",
+                                            "start": 10,
+                                            "end": 14,
+                                            "raw": "[bc]",
+                                            "unicodeSets": false,
+                                            "negate": false,
+                                            "elements": [
+                                              {
+                                                "type": "Character",
+                                                "parent": "♻️../..",
+                                                "start": 11,
+                                                "end": 12,
+                                                "raw": "b",
+                                                "value": 98
+                                              },
+                                              {
+                                                "type": "Character",
+                                                "parent": "♻️../..",
+                                                "start": 12,
+                                                "end": 13,
+                                                "raw": "c",
+                                                "value": 99
+                                              }
+                                            ]
+                                          }
+                                        },
+                                        {
+                                          "type": "Assertion",
+                                          "parent": "♻️../..",
+                                          "start": 17,
+                                          "end": 26,
+                                          "raw": "(?<!a{2})",
+                                          "kind": "lookbehind",
+                                          "negate": true,
+                                          "alternatives": [
+                                            {
+                                              "type": "Alternative",
+                                              "parent": "♻️../..",
+                                              "start": 21,
+                                              "end": 25,
+                                              "raw": "a{2}",
+                                              "elements": [
+                                                {
+                                                  "type": "Quantifier",
+                                                  "parent": "♻️../..",
+                                                  "start": 21,
+                                                  "end": 25,
+                                                  "raw": "a{2}",
+                                                  "min": 2,
+                                                  "max": 2,
+                                                  "greedy": true,
+                                                  "element": {
+                                                    "type": "Character",
+                                                    "parent": "♻️..",
+                                                    "start": 21,
+                                                    "end": 22,
+                                                    "raw": "a",
+                                                    "value": 97
+                                                  }
+                                                }
+                                              ]
+                                            }
+                                          ]
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": []
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 27,
+                                  "end": 28,
+                                  "raw": "d",
+                                  "value": 100
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 34,
+                          "raw": "\\w{3}",
+                          "min": 3,
+                          "max": 3,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 29,
+                            "end": 31,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 37,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 39,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 40,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=a(\\2)b(..\\1))b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(?<=a(\\2)b(..\\1))b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?<=a(\\2)b(..\\1))b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?<=a(\\2)b(..\\1))b",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 18,
+                  "raw": "(?<=a(\\2)b(..\\1))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 17,
+                      "raw": "a(\\2)b(..\\1)",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 10,
+                          "raw": "(\\2)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 9,
+                              "raw": "\\2",
+                              "elements": [
+                                {
+                                  "type": "Backreference",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 9,
+                                  "raw": "\\2",
+                                  "ref": 2,
+                                  "ambiguous": false,
+                                  "resolved": "♻️../../../../../3"
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../3/alternatives/0/elements/2"
+                          ]
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 17,
+                          "raw": "(..\\1)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 12,
+                              "end": 16,
+                              "raw": "..\\1",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "Backreference",
+                                  "parent": "♻️../..",
+                                  "start": 14,
+                                  "end": 16,
+                                  "raw": "\\1",
+                                  "ref": 1,
+                                  "ambiguous": false,
+                                  "resolved": "♻️../../../../../1"
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../1/alternatives/0/elements/0"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 20,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=a.c)\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(?<=a.c)\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(?<=a.c)\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?<=a.c)\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<=a.c)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "a.c",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 13,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 15,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=a[a-z])\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?<=a[a-z])\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "(?<=a[a-z])\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "(?<=a[a-z])\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "(?<=a[a-z])",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 11,
+                      "raw": "a[a-z]",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 11,
+                          "raw": "[a-z]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "CharacterClassRange",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 10,
+                              "raw": "a-z",
+                              "min": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 7,
+                                "end": 8,
+                                "raw": "a",
+                                "value": 97
+                              },
+                              "max": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 9,
+                                "end": 10,
+                                "raw": "z",
+                                "value": 122
+                              }
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 14,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 16,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 18,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 19,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=a[a-z][a-z])\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/(?<=a[a-z][a-z])\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "(?<=a[a-z][a-z])\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "(?<=a[a-z][a-z])\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 17,
+                  "raw": "(?<=a[a-z][a-z])",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 16,
+                      "raw": "a[a-z][a-z]",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 11,
+                          "raw": "[a-z]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "CharacterClassRange",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 10,
+                              "raw": "a-z",
+                              "min": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 7,
+                                "end": 8,
+                                "raw": "a",
+                                "value": 97
+                              },
+                              "max": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 9,
+                                "end": 10,
+                                "raw": "z",
+                                "value": 122
+                              }
+                            }
+                          ]
+                        },
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 16,
+                          "raw": "[a-z]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "CharacterClassRange",
+                              "parent": "♻️../..",
+                              "start": 12,
+                              "end": 15,
+                              "raw": "a-z",
+                              "min": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "a",
+                                "value": 97
+                              },
+                              "max": {
+                                "type": "Character",
+                                "parent": "♻️..",
+                                "start": 14,
+                                "end": 15,
+                                "raw": "z",
+                                "value": 122
+                              }
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 19,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 21,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 23,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 24,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=a[a-z]{2})\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(?<=a[a-z]{2})\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "(?<=a[a-z]{2})\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "(?<=a[a-z]{2})\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<=a[a-z]{2})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 14,
+                      "raw": "a[a-z]{2}",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 14,
+                          "raw": "[a-z]{2}",
+                          "min": 2,
+                          "max": 2,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 6,
+                            "end": 11,
+                            "raw": "[a-z]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterClassRange",
+                                "parent": "♻️../..",
+                                "start": 7,
+                                "end": 10,
+                                "raw": "a-z",
+                                "min": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                "max": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "z",
+                                  "value": 122
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 17,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 19,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 21,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 22,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=a\\wc)\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<=a\\wc)\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<=a\\wc)\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<=a\\wc)\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<=a\\wc)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "a\\wc",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 12,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 14,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 16,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=ab(?=c)\\wd)\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?<=ab(?=c)\\wd)\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?<=ab(?=c)\\wd)\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(?<=ab(?=c)\\wd)\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 16,
+                  "raw": "(?<=ab(?=c)\\wd)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 15,
+                      "raw": "ab(?=c)\\wd",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 12,
+                          "raw": "(?=c)",
+                          "kind": "lookahead",
+                          "negate": false,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 10,
+                              "end": 11,
+                              "raw": "c",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 10,
+                                  "end": 11,
+                                  "raw": "c",
+                                  "value": 99
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 14,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": "d",
+                          "value": 100
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 18,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 20,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=abc)\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(?<=abc)\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(?<=abc)\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?<=abc)\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<=abc)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "abc",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 13,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 15,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=a{1})\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<=a{1})\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<=a{1})\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<=a{1})\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<=a{1})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "a{1}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 9,
+                          "raw": "a{1}",
+                          "min": 1,
+                          "max": 1,
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "a",
+                            "value": 97
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 12,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 14,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 16,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=a{1}[a-z]{2})\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/(?<=a{1}[a-z]{2})\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "(?<=a{1}[a-z]{2})\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "(?<=a{1}[a-z]{2})\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 18,
+                  "raw": "(?<=a{1}[a-z]{2})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 17,
+                      "raw": "a{1}[a-z]{2}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 9,
+                          "raw": "a{1}",
+                          "min": 1,
+                          "max": 1,
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "a",
+                            "value": 97
+                          }
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 17,
+                          "raw": "[a-z]{2}",
+                          "min": 2,
+                          "max": 2,
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 14,
+                            "raw": "[a-z]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "CharacterClassRange",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 13,
+                                "raw": "a-z",
+                                "min": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 10,
+                                  "end": 11,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                "max": {
+                                  "type": "Character",
+                                  "parent": "♻️..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": "z",
+                                  "value": 122
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 20,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 22,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 24,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 25,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=a{1}b{1})\\w\\w\\w/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?<=a{1}b{1})\\w\\w\\w/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?<=a{1}b{1})\\w\\w\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(?<=a{1}b{1})\\w\\w\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<=a{1}b{1})",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 13,
+                      "raw": "a{1}b{1}",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 9,
+                          "raw": "a{1}",
+                          "min": 1,
+                          "max": 1,
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 5,
+                            "end": 6,
+                            "raw": "a",
+                            "value": 97
+                          }
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 13,
+                          "raw": "b{1}",
+                          "min": 1,
+                          "max": 1,
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "b",
+                            "value": 98
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 16,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 18,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 20,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<=b|c)\\w/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?<=b|c)\\w/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?<=b|c)\\w",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?<=b|c)\\w",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<=b|c)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "c",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?=(\\w))(?<=(\\1))./i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?=(\\w))(?<=(\\1))./i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?=(\\w))(?<=(\\1)).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?=(\\w))(?<=(\\1)).",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?=(\\w))",
+                  "kind": "lookahead",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 8,
+                      "raw": "(\\w)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 8,
+                          "raw": "(\\w)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 5,
+                              "end": 7,
+                              "raw": "\\w",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 5,
+                                  "end": 7,
+                                  "raw": "\\w",
+                                  "kind": "word",
+                                  "negate": false
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../1/alternatives/0/elements/0/alternatives/0/elements/0"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 18,
+                  "raw": "(?<=(\\1))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 17,
+                      "raw": "(\\1)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 17,
+                          "raw": "(\\1)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 14,
+                              "end": 16,
+                              "raw": "\\1",
+                              "elements": [
+                                {
+                                  "type": "Backreference",
+                                  "parent": "♻️../..",
+                                  "start": 14,
+                                  "end": 16,
+                                  "raw": "\\1",
+                                  "ref": 1,
+                                  "ambiguous": false,
+                                  "resolved": "♻️../../../../../../../../../0/alternatives/0/elements/0"
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?=(abcdefg))(?<=\\1)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(?=(abcdefg))(?<=\\1)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "(?=(abcdefg))(?<=\\1)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "(?=(abcdefg))(?<=\\1)",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?=(abcdefg))",
+                  "kind": "lookahead",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 13,
+                      "raw": "(abcdefg)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 13,
+                          "raw": "(abcdefg)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 5,
+                              "end": 12,
+                              "raw": "abcdefg",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 5,
+                                  "end": 6,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 7,
+                                  "raw": "b",
+                                  "value": 98
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "c",
+                                  "value": 99
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 9,
+                                  "raw": "d",
+                                  "value": 100
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "e",
+                                  "value": 101
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 10,
+                                  "end": 11,
+                                  "raw": "f",
+                                  "value": 102
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "g",
+                                  "value": 103
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../1/alternatives/0/elements/0"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 21,
+                  "raw": "(?<=\\1)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 20,
+                      "raw": "\\1",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 20,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0/alternatives/0/elements/0"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 22,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?=(abcdefghijklmn))(?<=\\1)a/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/(?=(abcdefghijklmn))(?<=\\1)a/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "(?=(abcdefghijklmn))(?<=\\1)a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "(?=(abcdefghijklmn))(?<=\\1)a",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 21,
+                  "raw": "(?=(abcdefghijklmn))",
+                  "kind": "lookahead",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 20,
+                      "raw": "(abcdefghijklmn)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 20,
+                          "raw": "(abcdefghijklmn)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 5,
+                              "end": 19,
+                              "raw": "abcdefghijklmn",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 5,
+                                  "end": 6,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 7,
+                                  "raw": "b",
+                                  "value": 98
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "c",
+                                  "value": 99
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 9,
+                                  "raw": "d",
+                                  "value": 100
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "e",
+                                  "value": 101
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 10,
+                                  "end": 11,
+                                  "raw": "f",
+                                  "value": 102
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "g",
+                                  "value": 103
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": "h",
+                                  "value": 104
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "i",
+                                  "value": 105
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 14,
+                                  "end": 15,
+                                  "raw": "j",
+                                  "value": 106
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 15,
+                                  "end": 16,
+                                  "raw": "k",
+                                  "value": 107
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 16,
+                                  "end": 17,
+                                  "raw": "l",
+                                  "value": 108
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 17,
+                                  "end": 18,
+                                  "raw": "m",
+                                  "value": 109
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 18,
+                                  "end": 19,
+                                  "raw": "n",
+                                  "value": 110
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../1/alternatives/0/elements/0"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 28,
+                  "raw": "(?<=\\1)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 25,
+                      "end": 27,
+                      "raw": "\\1",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 25,
+                          "end": 27,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0/alternatives/0/elements/0"
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 30,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?=(abcdefghijklmn))(?<=\\1)a/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/(?=(abcdefghijklmn))(?<=\\1)a/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "(?=(abcdefghijklmn))(?<=\\1)a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "(?=(abcdefghijklmn))(?<=\\1)a",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 21,
+                  "raw": "(?=(abcdefghijklmn))",
+                  "kind": "lookahead",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 20,
+                      "raw": "(abcdefghijklmn)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 20,
+                          "raw": "(abcdefghijklmn)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 5,
+                              "end": 19,
+                              "raw": "abcdefghijklmn",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 5,
+                                  "end": 6,
+                                  "raw": "a",
+                                  "value": 97
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 6,
+                                  "end": 7,
+                                  "raw": "b",
+                                  "value": 98
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 7,
+                                  "end": 8,
+                                  "raw": "c",
+                                  "value": 99
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 9,
+                                  "raw": "d",
+                                  "value": 100
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "e",
+                                  "value": 101
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 10,
+                                  "end": 11,
+                                  "raw": "f",
+                                  "value": 102
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "g",
+                                  "value": 103
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": "h",
+                                  "value": 104
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "i",
+                                  "value": 105
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 14,
+                                  "end": 15,
+                                  "raw": "j",
+                                  "value": 106
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 15,
+                                  "end": 16,
+                                  "raw": "k",
+                                  "value": 107
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 16,
+                                  "end": 17,
+                                  "raw": "l",
+                                  "value": 108
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 17,
+                                  "end": 18,
+                                  "raw": "m",
+                                  "value": 109
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 18,
+                                  "end": 19,
+                                  "raw": "n",
+                                  "value": 110
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../1/alternatives/0/elements/0"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 28,
+                  "raw": "(?<=\\1)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 25,
+                      "end": 27,
+                      "raw": "\\1",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 25,
+                          "end": 27,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0/alternatives/0/elements/0"
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\w(\\w))(?<=\\1\\2\\1)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(\\w(\\w))(?<=\\1\\2\\1)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(\\w(\\w))(?<=\\1\\2\\1)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(\\w(\\w))(?<=\\1\\2\\1)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(\\w(\\w))",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "\\w(\\w)",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 8,
+                          "raw": "(\\w)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 5,
+                              "end": 7,
+                              "raw": "\\w",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 5,
+                                  "end": 7,
+                                  "raw": "\\w",
+                                  "kind": "word",
+                                  "negate": false
+                                }
+                              ]
+                            }
+                          ],
+                          "references": [
+                            "♻️../../../../../1/alternatives/0/elements/1"
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1/alternatives/0/elements/0",
+                    "♻️../1/alternatives/0/elements/2"
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 20,
+                  "raw": "(?<=\\1\\2\\1)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 19,
+                      "raw": "\\1\\2\\1",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 15,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 17,
+                          "raw": "\\2",
+                          "ref": 2,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0/alternatives/0/elements/1"
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 19,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(abc\\1)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(abc\\1)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(abc\\1)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(abc\\1)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(abc\\1)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 7,
+                      "raw": "abc\\1",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "c",
+                          "value": 99
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../.."
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️alternatives/0/elements/3"
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(abc\\1)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(abc\\1)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(abc\\1)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(abc\\1)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(abc\\1)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 7,
+                      "raw": "abc\\1",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "c",
+                          "value": 99
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../.."
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️alternatives/0/elements/3"
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.*(?<=(..|...|....))(.*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/.*(?<=(..|...|....))(.*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": ".*(?<=(..|...|....))(.*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": ".*(?<=(..|...|....))(.*)",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 21,
+                  "raw": "(?<=(..|...|....))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 20,
+                      "raw": "(..|...|....)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 20,
+                          "raw": "(..|...|....)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 10,
+                              "raw": "..",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 9,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": ".",
+                                  "kind": "any"
+                                }
+                              ]
+                            },
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 14,
+                              "raw": "...",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": ".",
+                                  "kind": "any"
+                                }
+                              ]
+                            },
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 15,
+                              "end": 19,
+                              "raw": "....",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 15,
+                                  "end": 16,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 16,
+                                  "end": 17,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 17,
+                                  "end": 18,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 18,
+                                  "end": 19,
+                                  "raw": ".",
+                                  "kind": "any"
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 25,
+                  "raw": "(.*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 22,
+                      "end": 24,
+                      "raw": ".*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 24,
+                          "raw": ".*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 22,
+                            "end": 23,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 26,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.*(?<=(xx|...))(.*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/.*(?<=(xx|...))(.*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": ".*(?<=(xx|...))(.*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": ".*(?<=(xx|...))(.*)",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 16,
+                  "raw": "(?<=(xx|...))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 15,
+                      "raw": "(xx|...)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 15,
+                          "raw": "(xx|...)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 10,
+                              "raw": "xx",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 9,
+                                  "raw": "x",
+                                  "value": 120
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "x",
+                                  "value": 120
+                                }
+                              ]
+                            },
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 14,
+                              "raw": "...",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": ".",
+                                  "kind": "any"
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 20,
+                  "raw": "(.*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 17,
+                      "end": 19,
+                      "raw": ".*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 19,
+                          "raw": ".*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 17,
+                            "end": 18,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.*(?<=(xx|...|....))(.*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/.*(?<=(xx|...|....))(.*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": ".*(?<=(xx|...|....))(.*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": ".*(?<=(xx|...|....))(.*)",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 21,
+                  "raw": "(?<=(xx|...|....))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 20,
+                      "raw": "(xx|...|....)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 20,
+                          "raw": "(xx|...|....)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 10,
+                              "raw": "xx",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 9,
+                                  "raw": "x",
+                                  "value": 120
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "x",
+                                  "value": 120
+                                }
+                              ]
+                            },
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 14,
+                              "raw": "...",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": ".",
+                                  "kind": "any"
+                                }
+                              ]
+                            },
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 15,
+                              "end": 19,
+                              "raw": "....",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 15,
+                                  "end": 16,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 16,
+                                  "end": 17,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 17,
+                                  "end": 18,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 18,
+                                  "end": 19,
+                                  "raw": ".",
+                                  "kind": "any"
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 25,
+                  "raw": "(.*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 22,
+                      "end": 24,
+                      "raw": ".*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 24,
+                          "raw": ".*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 22,
+                            "end": 23,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 26,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.*(?<=(xx|xxx))(.*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/.*(?<=(xx|xxx))(.*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": ".*(?<=(xx|xxx))(.*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": ".*(?<=(xx|xxx))(.*)",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 2,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 16,
+                  "raw": "(?<=(xx|xxx))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 15,
+                      "raw": "(xx|xxx)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 15,
+                          "raw": "(xx|xxx)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 10,
+                              "raw": "xx",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 9,
+                                  "raw": "x",
+                                  "value": 120
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 9,
+                                  "end": 10,
+                                  "raw": "x",
+                                  "value": 120
+                                }
+                              ]
+                            },
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 14,
+                              "raw": "xxx",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "x",
+                                  "value": 120
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": "x",
+                                  "value": 120
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "x",
+                                  "value": 120
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 20,
+                  "raw": "(.*)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 17,
+                      "end": 19,
+                      "raw": ".*",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 19,
+                          "raw": ".*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 17,
+                            "end": 18,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\Bdef/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/\\Bdef/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "\\Bdef",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "\\Bdef",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\B",
+                  "kind": "word",
+                  "negate": true
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "d",
+                  "value": 100
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "e",
+                  "value": 101
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "f",
+                  "value": 102
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\D(?<=([ab]+))(\\w)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/\\D(?<=([ab]+))(\\w)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "\\D(?<=([ab]+))(\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "\\D(?<=([ab]+))(\\w)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\D",
+                  "kind": "digit",
+                  "negate": true
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 15,
+                  "raw": "(?<=([ab]+))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 14,
+                      "raw": "([ab]+)",
+                      "elements": [
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 14,
+                          "raw": "([ab]+)",
+                          "name": null,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 13,
+                              "raw": "[ab]+",
+                              "elements": [
+                                {
+                                  "type": "Quantifier",
+                                  "parent": "♻️../..",
+                                  "start": 8,
+                                  "end": 13,
+                                  "raw": "[ab]+",
+                                  "min": 1,
+                                  "max": "$$Infinity",
+                                  "greedy": true,
+                                  "element": {
+                                    "type": "CharacterClass",
+                                    "parent": "♻️..",
+                                    "start": 8,
+                                    "end": 12,
+                                    "raw": "[ab]",
+                                    "unicodeSets": false,
+                                    "negate": false,
+                                    "elements": [
+                                      {
+                                        "type": "Character",
+                                        "parent": "♻️../..",
+                                        "start": 9,
+                                        "end": 10,
+                                        "raw": "a",
+                                        "value": 97
+                                      },
+                                      {
+                                        "type": "Character",
+                                        "parent": "♻️../..",
+                                        "start": 10,
+                                        "end": 11,
+                                        "raw": "b",
+                                        "value": 98
+                                      }
+                                    ]
+                                  }
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 19,
+                  "raw": "(\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 18,
+                      "raw": "\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 18,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 20,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\w+(?<=$)/gm": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/\\w+(?<=$)/gm",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "\\w+(?<=$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "\\w+(?<=$)",
+              "elements": [
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "\\w+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 1,
+                    "end": 3,
+                    "raw": "\\w",
+                    "kind": "word",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 10,
+                  "raw": "(?<=$)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "$",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 13,
+          "raw": "gm",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^(f)oo(?<=^\\1o+)$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^(f)oo(?<=^\\1o+)$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^(f)oo(?<=^\\1o+)$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^(f)oo(?<=^\\1o+)$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(f)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "f",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "f",
+                          "value": 102
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../4/alternatives/0/elements/1"
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 17,
+                  "raw": "(?<=^\\1o+)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 16,
+                      "raw": "^\\1o+",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 14,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../1"
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 16,
+                          "raw": "o+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 14,
+                            "end": 15,
+                            "raw": "o",
+                            "value": 111
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 19,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^(f)oo(?<=^\\1o+)$/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^(f)oo(?<=^\\1o+)$/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^(f)oo(?<=^\\1o+)$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^(f)oo(?<=^\\1o+)$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(f)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "f",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "f",
+                          "value": 102
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../4/alternatives/0/elements/1"
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 17,
+                  "raw": "(?<=^\\1o+)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 16,
+                      "raw": "^\\1o+",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 14,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../1"
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 16,
+                          "raw": "o+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 14,
+                            "end": 15,
+                            "raw": "o",
+                            "value": 111
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^(f)oo(?<=^\\1o+).$/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^(f)oo(?<=^\\1o+).$/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^(f)oo(?<=^\\1o+).$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^(f)oo(?<=^\\1o+).$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(f)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "f",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "f",
+                          "value": 102
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../4/alternatives/0/elements/1"
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 17,
+                  "raw": "(?<=^\\1o+)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 16,
+                      "raw": "^\\1o+",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 14,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../1"
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 16,
+                          "raw": "o+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 14,
+                            "end": 15,
+                            "raw": "o",
+                            "value": 111
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^.(?<=a)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/^.(?<=a)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^.(?<=a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^.(?<=a)",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 9,
+                  "raw": "(?<=a)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^f..(?<=.oo)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^f..(?<=.oo)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^f..(?<=.oo)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^f..(?<=.oo)",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 13,
+                  "raw": "(?<=.oo)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 12,
+                      "raw": ".oo",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "o",
+                          "value": 111
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^f.o(?<!foo)$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^f.o(?<!foo)$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^f.o(?<!foo)$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^f.o(?<!foo)$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 13,
+                  "raw": "(?<!foo)",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 12,
+                      "raw": "foo",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "o",
+                          "value": 111
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^f.o(?<=foo)$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^f.o(?<=foo)$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^f.o(?<=foo)$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^f.o(?<=foo)$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 13,
+                  "raw": "(?<=foo)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 12,
+                      "raw": "foo",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "o",
+                          "value": 111
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^f\\w\\w(?<=\\woo)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^f\\w\\w(?<=\\woo)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^f\\w\\w(?<=\\woo)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^f\\w\\w(?<=\\woo)",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 5,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 7,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 16,
+                  "raw": "(?<=\\woo)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 15,
+                      "raw": "\\woo",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 13,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": "o",
+                          "value": 111
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^faaao?(?<=^f[oa]+(?=o))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^faaao?(?<=^f[oa]+(?=o))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^faaao?(?<=^f[oa]+(?=o))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^faaao?(?<=^f[oa]+(?=o))",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 8,
+                  "raw": "o?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "Character",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 7,
+                    "raw": "o",
+                    "value": 111
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 25,
+                  "raw": "(?<=^f[oa]+(?=o))",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 24,
+                      "raw": "^f[oa]+(?=o)",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 19,
+                          "raw": "[oa]+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterClass",
+                            "parent": "♻️..",
+                            "start": 14,
+                            "end": 18,
+                            "raw": "[oa]",
+                            "unicodeSets": false,
+                            "negate": false,
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 15,
+                                "end": 16,
+                                "raw": "o",
+                                "value": 111
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 16,
+                                "end": 17,
+                                "raw": "a",
+                                "value": 97
+                              }
+                            ]
+                          }
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 24,
+                          "raw": "(?=o)",
+                          "kind": "lookahead",
+                          "negate": false,
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 22,
+                              "end": 23,
+                              "raw": "o",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 22,
+                                  "end": 23,
+                                  "raw": "o",
+                                  "value": 111
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 26,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^foo(?<!foo)$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^foo(?<!foo)$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^foo(?<!foo)$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^foo(?<!foo)$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 13,
+                  "raw": "(?<!foo)",
+                  "kind": "lookbehind",
+                  "negate": true,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 12,
+                      "raw": "foo",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "o",
+                          "value": 111
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^foo(?<=^fo+)$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^foo(?<=^fo+)$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^foo(?<=^fo+)$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^foo(?<=^fo+)$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 14,
+                  "raw": "(?<=^fo+)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 13,
+                      "raw": "^fo+",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 13,
+                          "raw": "o+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 11,
+                            "end": 12,
+                            "raw": "o",
+                            "value": 111
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^foo(?<=foo)$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^foo(?<=foo)$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^foo(?<=foo)$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^foo(?<=foo)$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 13,
+                  "raw": "(?<=foo)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 12,
+                      "raw": "foo",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "o",
+                          "value": 111
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^foooo(?<=^fo*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^foooo(?<=^fo*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^foooo(?<=^fo*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^foooo(?<=^fo*)",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 16,
+                  "raw": "(?<=^fo*)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 15,
+                      "raw": "^fo*",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 15,
+                          "raw": "o*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 13,
+                            "end": 14,
+                            "raw": "o",
+                            "value": 111
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^foooo(?<=fo*)$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^foooo(?<=fo*)$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^foooo(?<=fo*)$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^foooo(?<=fo*)$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 15,
+                  "raw": "(?<=fo*)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 14,
+                      "raw": "fo*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 14,
+                          "raw": "o*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 12,
+                            "end": 13,
+                            "raw": "o",
+                            "value": 111
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^foooo(?<=fo+)$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^foooo(?<=fo+)$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^foooo(?<=fo+)$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^foooo(?<=fo+)$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": "f",
+                  "value": 102
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 7,
+                  "raw": "o",
+                  "value": 111
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 15,
+                  "raw": "(?<=fo+)",
+                  "kind": "lookbehind",
+                  "negate": false,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 14,
+                      "raw": "fo+",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 14,
+                          "raw": "o+",
+                          "min": 1,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "Character",
+                            "parent": "♻️..",
+                            "start": 12,
+                            "end": 13,
+                            "raw": "o",
+                            "value": 111
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/regexp-match-indices-and-regexp-named-groups.json b/test/fixtures/parser/literal/test262/regexp-match-indices-and-regexp-named-groups.json
new file mode 100644
index 0000000..32f9930
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/regexp-match-indices-and-regexp-named-groups.json
@@ -0,0 +1,2733 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/match-indices/indices-array-non-unicode-match.js",
+    "test/built-ins/RegExp/match-indices/indices-array-unicode-match.js",
+    "test/built-ins/RegExp/match-indices/indices-array-unicode-property-names.js",
+    "test/built-ins/RegExp/match-indices/indices-groups-object-unmatched.js",
+    "test/built-ins/RegExp/match-indices/indices-groups-object.js",
+    "test/built-ins/RegExp/match-indices/indices-groups-properties.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/(?<$>a)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?<$>a)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<$>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<$>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<$>a)",
+                  "name": "$",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<$𐒤>a)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?<$𐒤>a)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<$𐒤>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<$𐒤>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<$𐒤>a)",
+                  "name": "$𐒤",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 13,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u{03C0}>a)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?<\\u{03C0}>a)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(?<\\u{03C0}>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?<\\u{03C0}>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<\\u{03C0}>a)",
+                  "name": "π",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 14,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 18,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<_>a)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?<_>a)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<_>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<_>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<_>a)",
+                  "name": "_",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<_\\u200C>a)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<_\\u200C>a)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?<_\\u200C>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?<_\\u200C>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<_\\u200C>a)",
+                  "name": "_‌",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 13,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 17,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<_\\u200D>a)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<_\\u200D>a)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?<_\\u200D>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?<_\\u200D>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<_\\u200D>a)",
+                  "name": "_‍",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 13,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 17,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<__proto__>.)/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?<__proto__>.)/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<__proto__>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<__proto__>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 16,
+                  "raw": "(?<__proto__>.)",
+                  "name": "__proto__",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 15,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>.)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../5"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 15,
+                  "raw": "(?<b>.)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 14,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../4"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 22,
+                  "raw": "(?<c>.)",
+                  "name": "c",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 20,
+                      "end": 21,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 21,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 27,
+                  "raw": "\\k<c>",
+                  "ref": "c",
+                  "ambiguous": false,
+                  "resolved": "♻️../2"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 32,
+                  "raw": "\\k<b>",
+                  "ref": "b",
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 37,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>.)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../5"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 15,
+                  "raw": "(?<b>.)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 14,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../4"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 22,
+                  "raw": "(?<c>.)",
+                  "name": "c",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 20,
+                      "end": 21,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 21,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 27,
+                  "raw": "\\k<c>",
+                  "ref": "c",
+                  "ambiguous": false,
+                  "resolved": "♻️../2"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 32,
+                  "raw": "\\k<b>",
+                  "ref": "b",
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 37,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 40,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>.)/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?<a>.)/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<a>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<a>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>.)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>.)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?<a>.)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<a>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<a>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>.)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>a).|(?<x>x)/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?<a>a).|(?<x>x)/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "(?<a>a).|(?<x>x)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?<a>a).",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 10,
+              "end": 17,
+              "raw": "(?<x>x)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 17,
+                  "raw": "(?<x>x)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 15,
+                      "end": 16,
+                      "raw": "x",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 16,
+                          "raw": "x",
+                          "value": 120
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<fst>.)|(?<snd>.)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/(?<fst>.)|(?<snd>.)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?<fst>.)|(?<snd>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<fst>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<fst>.)",
+                  "name": "fst",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 11,
+              "end": 20,
+              "raw": "(?<snd>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 20,
+                  "raw": "(?<snd>.)",
+                  "name": "snd",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 19,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 23,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<x>.)/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?<x>.)/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<x>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<x>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<x>.)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<π>a)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?<π>a)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<π>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<π>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<π>a)",
+                  "name": "π",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<ಠ_ಠ>a)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?<ಠ_ಠ>a)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<ಠ_ಠ>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<ಠ_ಠ>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<ಠ_ಠ>a)",
+                  "name": "ಠ_ಠ",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 13,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\w\\w)(\\W)?/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(\\w\\w)(\\W)?/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(\\w\\w)(\\W)?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(\\w\\w)(\\W)?",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 6,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 12,
+                  "raw": "(\\W)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 7,
+                    "end": 11,
+                    "raw": "(\\W)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 8,
+                        "end": 10,
+                        "raw": "\\W",
+                        "elements": [
+                          {
+                            "type": "CharacterSet",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 10,
+                            "raw": "\\W",
+                            "kind": "word",
+                            "negate": true
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\w\\w)(\\W)?/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(\\w\\w)(\\W)?/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(\\w\\w)(\\W)?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(\\w\\w)(\\W)?",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 6,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 12,
+                  "raw": "(\\W)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 7,
+                    "end": 11,
+                    "raw": "(\\W)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 8,
+                        "end": 10,
+                        "raw": "\\W",
+                        "elements": [
+                          {
+                            "type": "CharacterSet",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 10,
+                            "raw": "\\W",
+                            "kind": "word",
+                            "negate": true
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 15,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\w\\w)(\\w)/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(\\w\\w)(\\w)/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(\\w\\w)(\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(\\w\\w)(\\w)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 6,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 11,
+                  "raw": "(\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 10,
+                      "raw": "\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 10,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\w\\w)(\\w)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(\\w\\w)(\\w)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(\\w\\w)(\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(\\w\\w)(\\w)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 6,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 11,
+                  "raw": "(\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 10,
+                      "raw": "\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 10,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 14,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\w\\w\\w)/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(\\w\\w\\w)/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(\\w\\w\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(\\w\\w\\w)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(\\w\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "\\w\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 6,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\w\\w\\w)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(\\w\\w\\w)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(\\w\\w\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(\\w\\w\\w)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(\\w\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "\\w\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 6,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 12,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(a)/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/(a)/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "(a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "(a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(a)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/(a)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "(a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "(a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 7,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(\\w\\w)/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/.(\\w\\w)/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": ".(\\w\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": ".(\\w\\w)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "(\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 7,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 5,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(\\w\\w)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/.(\\w\\w)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": ".(\\w\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": ".(\\w\\w)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "(\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 7,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 5,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(a)(.)/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/.(a)(.)/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": ".(a)(.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": ".(a)(.)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 8,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(a)(.)/du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/.(a)(.)/du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": ".(a)(.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": ".(a)(.)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 8,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(a)./d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/.(a)./d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": ".(a).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": ".(a).",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(a)./du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/.(a)./du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": ".(a).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": ".(a).",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 9,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/regexp-match-indices.json b/test/fixtures/parser/literal/test262/regexp-match-indices.json
new file mode 100644
index 0000000..aa71a94
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/regexp-match-indices.json
@@ -0,0 +1,527 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/match-indices/indices-array-element.js",
+    "test/built-ins/RegExp/match-indices/indices-array-unmatched.js",
+    "test/built-ins/RegExp/match-indices/indices-array.js",
+    "test/built-ins/RegExp/prototype/hasIndices/this-val-regexp.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/./dg": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./dg",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "dg",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./di": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./di",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "di",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./dm": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./dm",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "dm",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./ds": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./ds",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "ds",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./du": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./du",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "du",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/./dy": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./dy",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "dy",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/a/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/a/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b(c)/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/b(c)/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "b(c)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "b(c)",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(c)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "c",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 7,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/b(c)?/d": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/b(c)?/d",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "b(c)?",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "b(c)?",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "b",
+                  "value": 98
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 6,
+                  "raw": "(c)?",
+                  "min": 0,
+                  "max": 1,
+                  "greedy": true,
+                  "element": {
+                    "type": "CapturingGroup",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 5,
+                    "raw": "(c)",
+                    "name": null,
+                    "alternatives": [
+                      {
+                        "type": "Alternative",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "c",
+                        "elements": [
+                          {
+                            "type": "Character",
+                            "parent": "♻️../..",
+                            "start": 3,
+                            "end": 4,
+                            "raw": "c",
+                            "value": 99
+                          }
+                        ]
+                      }
+                    ],
+                    "references": []
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "d",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/regexp-modifiers.json b/test/fixtures/parser/literal/test262/regexp-modifiers.json
new file mode 100644
index 0000000..f5f786e
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/regexp-modifiers.json
@@ -0,0 +1,19297 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-dotAll-property.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-ignoreCase-flag.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-multiline-flag.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-dotAll.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-backreferences.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterClasses.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterEscapes.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-b.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-p.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-w.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-b.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-p.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-w.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-dotAll-flag.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-ignoreCase-property.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-multiline-flag.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-ignoreCase.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-dotAll-flag.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-ignoreCase-flag.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-multiline-property.js",
+    "test/built-ins/RegExp/regexp-modifiers/add-remove-modifiers.js",
+    "test/built-ins/RegExp/regexp-modifiers/changing-dotAll-flag-does-not-affect-dotAll-modifier.js",
+    "test/built-ins/RegExp/regexp-modifiers/changing-ignoreCase-flag-does-not-affect-ignoreCase-modifier.js",
+    "test/built-ins/RegExp/regexp-modifiers/changing-multiline-flag-does-not-affect-multiline-modifier.js",
+    "test/built-ins/RegExp/regexp-modifiers/nested-add-remove-modifiers.js",
+    "test/built-ins/RegExp/regexp-modifiers/nesting-add-dotAll-within-remove-dotAll.js",
+    "test/built-ins/RegExp/regexp-modifiers/nesting-add-ignoreCase-within-remove-ignoreCase.js",
+    "test/built-ins/RegExp/regexp-modifiers/nesting-add-multiline-within-remove-multiline.js",
+    "test/built-ins/RegExp/regexp-modifiers/nesting-remove-dotAll-within-add-dotAll.js",
+    "test/built-ins/RegExp/regexp-modifiers/nesting-remove-multiline-within-add-multiline.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-dotAll-does-not-affect-dotAll-property.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-dotAll-does-not-affect-ignoreCase-flag.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-dotAll-does-not-affect-multiline-flag.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-backreferences.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-characterClasses.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-characterEscapes.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-lower-b.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-lower-p.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-lower-w.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-upper-b.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-upper-p.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-upper-w.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-ignoreCase-does-not-affect-dotAll-flag.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-ignoreCase-does-not-affect-ignoreCase-property.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-ignoreCase-does-not-affect-multiline-flag.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-ignoreCase.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-multiline-does-not-affect-dotAll-flag.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-multiline-does-not-affect-ignoreCase-flag.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-multiline-does-not-affect-multiline-property.js",
+    "test/built-ins/RegExp/regexp-modifiers/remove-multiline.js",
+    "test/built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js",
+    "test/built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js",
+    "test/built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-nested.js",
+    "test/built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js",
+    "test/built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-set-as-flags.js",
+    "test/built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-nested.js",
+    "test/built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js",
+    "test/built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-i.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-m.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-multi-duplicate.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-s-escape.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-s.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-both-empty.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-code-point-repeat-i-1.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-code-point-repeat-i-2.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-no-colon-1.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-no-colon-2.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-no-colon-3.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-arbitrary.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-i.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-m.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-s.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-d.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-g.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-display-1.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-display-2.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-flag.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-u.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-uppercase-I.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-y.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwj.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwnbsp.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwnj.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-multi-duplicate.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-s-escape.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-code-point-repeat-i-1.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-code-point-repeat-i-2.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-arbitrary.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-i.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-m.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-s.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-d.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-g.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-display-1.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-display-2.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-flag.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-u.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-uppercase-I.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-y.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwj.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwnbsp.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwnj.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-m.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-s.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-unicode-case-fold-i.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-unicode-case-fold-s.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-m.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-s.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-unicode-case-fold-i.js",
+    "test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-unicode-case-fold-s.js",
+    "test/language/literals/regexp/early-err-modifiers-code-point-repeat-i-1.js",
+    "test/language/literals/regexp/early-err-modifiers-code-point-repeat-i-2.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-arbitrary.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-combining-i.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-combining-m.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-combining-s.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-d.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-g.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-non-display-1.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-non-display-2.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-non-flag.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-u.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-uppercase-I.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-y.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-zwj.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-zwnbsp.js",
+    "test/language/literals/regexp/early-err-modifiers-other-code-point-zwnj.js",
+    "test/language/literals/regexp/early-err-modifiers-should-not-case-fold-m.js",
+    "test/language/literals/regexp/early-err-modifiers-should-not-case-fold-s.js",
+    "test/language/literals/regexp/early-err-modifiers-should-not-unicode-case-fold-i.js",
+    "test/language/literals/regexp/early-err-modifiers-should-not-unicode-case-fold-s.js",
+    "test/language/literals/regexp/early-err-modifiers-should-not-unicode-escape-i.js",
+    "test/language/literals/regexp/early-err-modifiers-should-not-unicode-escape-m.js",
+    "test/language/literals/regexp/early-err-modifiers-should-not-unicode-escape-s.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/(?-1:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-1:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-:a)/: Invalid empty flags",
+        "index": 4
+      }
+    },
+    "/(?-I:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-I:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-M:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-M:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-Q:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-Q:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-S:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-S:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-d:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-d:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-g:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-g:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-i:(?-i:))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?-i:(?-i:))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?-i:(?-i:))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?-i:(?-i:))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?-i:(?-i:))",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 12,
+                      "raw": "(?-i:)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 12,
+                          "raw": "(?-i:)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 8,
+                            "end": 10,
+                            "raw": "-i",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 8,
+                              "end": 8,
+                              "raw": "",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": false
+                            },
+                            "remove": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "i",
+                              "ignoreCase": true,
+                              "multiline": false,
+                              "dotAll": false
+                            }
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 11,
+                              "raw": "",
+                              "elements": []
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?-i:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?-i:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?-i:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?-i:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?-i:)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?-i:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?-i:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?-i:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:.es)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?-i:.es)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?-i:.es)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?-i:.es)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?-i:.es)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": ".es",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:.es)/is": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?-i:.es)/is",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?-i:.es)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?-i:.es)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?-i:.es)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": ".es",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 13,
+          "raw": "is",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:Z\\B)/ui": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?-i:Z\\B)/ui",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?-i:Z\\B)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?-i:Z\\B)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?-i:Z\\B)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "Z\\B",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "Z",
+                          "value": 90
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 9,
+                          "raw": "\\B",
+                          "kind": "word",
+                          "negate": true
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 13,
+          "raw": "ui",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:[^ab])c/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?-i:[^ab])c/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?-i:[^ab])c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?-i:[^ab])c",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "(?-i:[^ab])",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 11,
+                      "raw": "[^ab]",
+                      "elements": [
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 11,
+                          "raw": "[^ab]",
+                          "unicodeSets": false,
+                          "negate": true,
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 9,
+                              "raw": "a",
+                              "value": 97
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "b",
+                              "value": 98
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:[ab])c/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?-i:[ab])c/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(?-i:[ab])c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(?-i:[ab])c",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?-i:[ab])",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": "[ab]",
+                      "elements": [
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 10,
+                          "raw": "[ab]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "a",
+                              "value": 97
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 9,
+                              "raw": "b",
+                              "value": 98
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:\\P{Lu})/ui": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(?-i:\\P{Lu})/ui",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?-i:\\P{Lu})",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?-i:\\P{Lu})",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?-i:\\P{Lu})",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 12,
+                      "raw": "\\P{Lu}",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 12,
+                          "raw": "\\P{Lu}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Lu",
+                          "negate": true
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 16,
+          "raw": "ui",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:\\W)/ui": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?-i:\\W)/ui",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-i:\\W)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-i:\\W)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-i:\\W)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "\\W",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 12,
+          "raw": "ui",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:\\b)/ui": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?-i:\\b)/ui",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-i:\\b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-i:\\b)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-i:\\b)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "\\b",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\b",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 12,
+          "raw": "ui",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:\\p{Lu})/ui": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(?-i:\\p{Lu})/ui",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?-i:\\p{Lu})",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?-i:\\p{Lu})",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?-i:\\p{Lu})",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 12,
+                      "raw": "\\p{Lu}",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 12,
+                          "raw": "\\p{Lu}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Lu",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 16,
+          "raw": "ui",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:\\u0061)b/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(?-i:\\u0061)b/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?-i:\\u0061)b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?-i:\\u0061)b",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?-i:\\u0061)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 12,
+                      "raw": "\\u0061",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 12,
+                          "raw": "\\u0061",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:\\u{0061})b/iu": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?-i:\\u{0061})b/iu",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?-i:\\u{0061})b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?-i:\\u{0061})b",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?-i:\\u{0061})",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 14,
+                      "raw": "\\u{0061}",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 14,
+                          "raw": "\\u{0061}",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 19,
+          "raw": "iu",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:\\w)/ui": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?-i:\\w)/ui",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-i:\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-i:\\w)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-i:\\w)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 12,
+          "raw": "ui",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:\\x61)b/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?-i:\\x61)b/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(?-i:\\x61)b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(?-i:\\x61)b",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?-i:\\x61)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": "\\x61",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 10,
+                          "raw": "\\x61",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:a(?i:b))c/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?-i:a(?i:b))c/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(?-i:a(?i:b))c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?-i:a(?i:b))c",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?-i:a(?i:b))",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 13,
+                      "raw": "a(?i:b)",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 13,
+                          "raw": "(?i:b)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "i",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "i",
+                              "ignoreCase": true,
+                              "multiline": false,
+                              "dotAll": false
+                            },
+                            "remove": null
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "b",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "b",
+                                  "value": 98
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:aB)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?-i:aB)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-i:aB)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-i:aB)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-i:aB)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "aB",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "B",
+                          "value": 66
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:es$)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?-i:es$)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?-i:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?-i:es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?-i:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:es$)/im": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?-i:es$)/im",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?-i:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?-i:es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?-i:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 13,
+          "raw": "im",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-i:fo)o/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?-i:fo)o/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?-i:fo)o",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?-i:fo)o",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-i:fo)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "fo",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "o",
+                          "value": 111
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "o",
+                  "value": 111
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-ii:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-ii:a)/: Duplicated flag 'i'",
+        "index": 4
+      }
+    },
+    "/(?-im:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?-im:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?-im:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?-im:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?-im:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "-im",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "im",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-im:)/im": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?-im:)/im",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?-im:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?-im:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?-im:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "-im",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "im",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "im",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-ims:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?-ims:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-ims:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-ims:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-ims:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "-ims",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "ims",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-ims:)/ims": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?-ims:)/ims",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-ims:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-ims:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-ims:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "-ims",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "ims",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 13,
+          "raw": "ims",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-imsi:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-imsi:a)/: Duplicated flag 'i'",
+        "index": 4
+      }
+    },
+    "/(?-is:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?-is:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?-is:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?-is:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?-is:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "-is",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "is",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-is:)/is": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?-is:)/is",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?-is:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?-is:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?-is:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "-is",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "is",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "is",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-ism:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?-ism:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-ism:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-ism:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-ism:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "-ism",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "ism",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-ism:)/ism": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?-ism:)/ism",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-ism:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-ism:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-ism:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "-ism",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "ism",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 13,
+          "raw": "ism",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-iͥ:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-iͥ:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-m:(?-m:))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?-m:(?-m:))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?-m:(?-m:))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?-m:(?-m:))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?-m:(?-m:))",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 12,
+                      "raw": "(?-m:)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 12,
+                          "raw": "(?-m:)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 8,
+                            "end": 10,
+                            "raw": "-m",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 8,
+                              "end": 8,
+                              "raw": "",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": false
+                            },
+                            "remove": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "m",
+                              "ignoreCase": false,
+                              "multiline": true,
+                              "dotAll": false
+                            }
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 11,
+                              "raw": "",
+                              "elements": []
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-m:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?-m:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?-m:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?-m:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?-m:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-m:)/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?-m:)/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?-m:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?-m:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?-m:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-m:es$)/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?-m:es$)/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?-m:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?-m:es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?-m:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-m:es$)/mi": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?-m:es$)/mi",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?-m:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?-m:es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?-m:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 13,
+          "raw": "mi",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-m:es(?m-:$)|js$)/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(?-m:es(?m-:$)|js$)/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?-m:es(?m-:$)|js$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(?-m:es(?m-:$)|js$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 20,
+                  "raw": "(?-m:es(?m-:$)|js$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 15,
+                      "raw": "es(?m-:$)",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 15,
+                          "raw": "(?m-:$)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 10,
+                            "end": 12,
+                            "raw": "m-",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 10,
+                              "end": 11,
+                              "raw": "m",
+                              "ignoreCase": false,
+                              "multiline": true,
+                              "dotAll": false
+                            },
+                            "remove": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 12,
+                              "end": 12,
+                              "raw": "",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": false
+                            }
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 13,
+                              "end": 14,
+                              "raw": "$",
+                              "elements": [
+                                {
+                                  "type": "Assertion",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "$",
+                                  "kind": "end"
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 19,
+                      "raw": "js$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 17,
+                          "raw": "j",
+                          "value": 106
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-m:es(?m:$)|js$)/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?-m:es(?m:$)|js$)/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?-m:es(?m:$)|js$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?-m:es(?m:$)|js$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 19,
+                  "raw": "(?-m:es(?m:$)|js$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 14,
+                      "raw": "es(?m:$)",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 14,
+                          "raw": "(?m:$)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "m",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 10,
+                              "end": 11,
+                              "raw": "m",
+                              "ignoreCase": false,
+                              "multiline": true,
+                              "dotAll": false
+                            },
+                            "remove": null
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 12,
+                              "end": 13,
+                              "raw": "$",
+                              "elements": [
+                                {
+                                  "type": "Assertion",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": "$",
+                                  "kind": "end"
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 15,
+                      "end": 18,
+                      "raw": "js$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 16,
+                          "raw": "j",
+                          "value": 106
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 17,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-m:es.$)/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?-m:es.$)/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?-m:es.$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?-m:es.$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?-m:es.$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": "es.$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-m:es.$)/ms": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?-m:es.$)/ms",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?-m:es.$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?-m:es.$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?-m:es.$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": "es.$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 14,
+          "raw": "ms",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-mi:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?-mi:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?-mi:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?-mi:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?-mi:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "-mi",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "mi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-mi:)/mi": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?-mi:)/mi",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?-mi:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?-mi:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?-mi:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "-mi",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "mi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "mi",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-mis:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?-mis:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-mis:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-mis:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-mis:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "-mis",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "mis",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-mis:)/mis": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?-mis:)/mis",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-mis:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-mis:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-mis:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "-mis",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "mis",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 13,
+          "raw": "mis",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-ms:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?-ms:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?-ms:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?-ms:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?-ms:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "-ms",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "ms",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-ms:)/ms": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?-ms:)/ms",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?-ms:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?-ms:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?-ms:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "-ms",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "ms",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "ms",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-msi:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?-msi:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-msi:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-msi:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-msi:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "-msi",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "msi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-msi:)/msi": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?-msi:)/msi",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-msi:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-msi:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-msi:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "-msi",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "msi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 13,
+          "raw": "msi",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-mͫ:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-mͫ:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-s\u0000:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-s\u0000:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-s)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-s)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-s:(?-s:))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?-s:(?-s:))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?-s:(?-s:))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?-s:(?-s:))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?-s:(?-s:))",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 12,
+                      "raw": "(?-s:)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 12,
+                          "raw": "(?-s:)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 8,
+                            "end": 10,
+                            "raw": "-s",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 8,
+                              "end": 8,
+                              "raw": "",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": false
+                            },
+                            "remove": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "s",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": true
+                            }
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 11,
+                              "raw": "",
+                              "elements": []
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-s:(?s-:^.$))/s": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?-s:(?s-:^.$))/s",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?-s:(?s-:^.$))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?-s:(?s-:^.$))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 16,
+                  "raw": "(?-s:(?s-:^.$))",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 15,
+                      "raw": "(?s-:^.$)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 15,
+                          "raw": "(?s-:^.$)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 8,
+                            "end": 10,
+                            "raw": "s-",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 8,
+                              "end": 9,
+                              "raw": "s",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": true
+                            },
+                            "remove": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 10,
+                              "end": 10,
+                              "raw": "",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": false
+                            }
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 14,
+                              "raw": "^.$",
+                              "elements": [
+                                {
+                                  "type": "Assertion",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "^",
+                                  "kind": "start"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "Assertion",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "$",
+                                  "kind": "end"
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "s",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-s:(?s:^.$))/s": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?-s:(?s:^.$))/s",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(?-s:(?s:^.$))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?-s:(?s:^.$))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?-s:(?s:^.$))",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 14,
+                      "raw": "(?s:^.$)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 14,
+                          "raw": "(?s:^.$)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "s",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 8,
+                              "end": 9,
+                              "raw": "s",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": true
+                            },
+                            "remove": null
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 10,
+                              "end": 13,
+                              "raw": "^.$",
+                              "elements": [
+                                {
+                                  "type": "Assertion",
+                                  "parent": "♻️../..",
+                                  "start": 10,
+                                  "end": 11,
+                                  "raw": "^",
+                                  "kind": "start"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "Assertion",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": "$",
+                                  "kind": "end"
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "s",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-s:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?-s:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?-s:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?-s:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?-s:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-s:)/s": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?-s:)/s",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?-s:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?-s:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?-s:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 9,
+          "raw": "s",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-s:.es$)/s": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?-s:.es$)/s",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?-s:.es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?-s:.es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?-s:.es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": ".es$",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "s",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-s:.es$)/sm": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?-s:.es$)/sm",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?-s:.es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?-s:.es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?-s:.es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": ".es$",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 14,
+          "raw": "sm",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-s:.es)/s": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?-s:.es)/s",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?-s:.es)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?-s:.es)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?-s:.es)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": ".es",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "s",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-s:.es)/si": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?-s:.es)/si",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?-s:.es)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?-s:.es)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?-s:.es)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": ".es",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 13,
+          "raw": "si",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-s:^.$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?-s:^.$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?-s:^.$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?-s:^.$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?-s:^.$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "^.$",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-s:^.$)/s": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?-s:^.$)/s",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?-s:^.$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?-s:^.$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?-s:^.$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "^.$",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "s",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-si:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?-si:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?-si:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?-si:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?-si:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "-si",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "si",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-si:)/si": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?-si:)/si",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?-si:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?-si:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?-si:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "-si",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "si",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "si",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-sim:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?-sim:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-sim:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-sim:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-sim:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "-sim",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "sim",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-sim:)/sim": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?-sim:)/sim",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-sim:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-sim:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-sim:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "-sim",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "sim",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 13,
+          "raw": "sim",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-sm:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?-sm:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?-sm:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?-sm:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?-sm:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "-sm",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "sm",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-sm:)/sm": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?-sm:)/sm",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?-sm:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?-sm:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?-sm:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "-sm",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 6,
+                      "raw": "sm",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 11,
+          "raw": "sm",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-smi:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?-smi:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-smi:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-smi:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-smi:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "-smi",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "smi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-smi:)/smi": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?-smi:)/smi",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?-smi:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?-smi:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?-smi:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "-smi",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 3,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 7,
+                      "raw": "smi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 13,
+          "raw": "smi",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?-s̀:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-s̀:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-s‌:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-s‌:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-s‍:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-s‍:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-s‎:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-s‎:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-s:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-s:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-u:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-u:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-y:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-y:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-İ:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-İ:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?-ſ:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?-ſ:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?1-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?1-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?1:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?1:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?I-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?I-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?I:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?I:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?M-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?M-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?M:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?M:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?Q-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?Q-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?Q:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?Q:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?S-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?S-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?S:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?S:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?\\u0069:a)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?\\u0069:a)/u: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?\\u006D:a)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?\\u006D:a)/u: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?\\u0073:a)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?\\u0073:a)/u: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?\\u{0073}-s:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?\\u{0073}-s:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?d-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?d-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?d:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?d:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?g-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?g-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?g:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?g:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?i-)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?i-)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?i-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?i-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?i-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?i-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?i-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:.es)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?i-:.es)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?i-:.es)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?i-:.es)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?i-:.es)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": ".es",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:.es)/s": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?i-:.es)/s",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?i-:.es)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?i-:.es)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?i-:.es)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": ".es",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "s",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:Z\\B)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?i-:Z\\B)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?i-:Z\\B)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?i-:Z\\B)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?i-:Z\\B)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "Z\\B",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "Z",
+                          "value": 90
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 9,
+                          "raw": "\\B",
+                          "kind": "word",
+                          "negate": true
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:[^ab])c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?i-:[^ab])c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?i-:[^ab])c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?i-:[^ab])c",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "(?i-:[^ab])",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 11,
+                      "raw": "[^ab]",
+                      "elements": [
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 11,
+                          "raw": "[^ab]",
+                          "unicodeSets": false,
+                          "negate": true,
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 9,
+                              "raw": "a",
+                              "value": 97
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "b",
+                              "value": 98
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:[ab])c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?i-:[ab])c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(?i-:[ab])c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(?i-:[ab])c",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?i-:[ab])",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": "[ab]",
+                      "elements": [
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 10,
+                          "raw": "[ab]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "a",
+                              "value": 97
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 9,
+                              "raw": "b",
+                              "value": 98
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:\\P{Lu})/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?i-:\\P{Lu})/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?i-:\\P{Lu})",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?i-:\\P{Lu})",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?i-:\\P{Lu})",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 12,
+                      "raw": "\\P{Lu}",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 12,
+                          "raw": "\\P{Lu}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Lu",
+                          "negate": true
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:\\W)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?i-:\\W)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?i-:\\W)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?i-:\\W)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?i-:\\W)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "\\W",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:\\b)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?i-:\\b)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?i-:\\b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?i-:\\b)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?i-:\\b)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "\\b",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\b",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:\\b)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?i-:\\b)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?i-:\\b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?i-:\\b)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?i-:\\b)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "\\b",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\b",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:\\p{Lu})/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?i-:\\p{Lu})/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?i-:\\p{Lu})",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?i-:\\p{Lu})",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?i-:\\p{Lu})",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 12,
+                      "raw": "\\p{Lu}",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 12,
+                          "raw": "\\p{Lu}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Lu",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:\\u0061)b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?i-:\\u0061)b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?i-:\\u0061)b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?i-:\\u0061)b",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?i-:\\u0061)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 12,
+                      "raw": "\\u0061",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 12,
+                          "raw": "\\u0061",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:\\u{0061})b/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?i-:\\u{0061})b/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?i-:\\u{0061})b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?i-:\\u{0061})b",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?i-:\\u{0061})",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 14,
+                      "raw": "\\u{0061}",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 14,
+                          "raw": "\\u{0061}",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:\\w)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?i-:\\w)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?i-:\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?i-:\\w)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?i-:\\w)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:\\w)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?i-:\\w)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?i-:\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?i-:\\w)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?i-:\\w)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:\\x61)b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?i-:\\x61)b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(?i-:\\x61)b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(?i-:\\x61)b",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?i-:\\x61)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": "\\x61",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 10,
+                          "raw": "\\x61",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:es$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?i-:es$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?i-:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?i-:es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?i-:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-:es$)/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?i-:es$)/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?i-:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?i-:es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?i-:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-i:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?i-i:a)/: Duplicated flag 'i'",
+        "index": 6
+      }
+    },
+    "/(?i-m:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?i-m:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?i-m:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?i-m:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?i-m:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "i-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-ms:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?i-ms:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?i-ms:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?i-ms:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?i-ms:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "i-ms",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "ms",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-s:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?i-s:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?i-s:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?i-s:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?i-s:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "i-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i-sm:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?i-sm:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?i-sm:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?i-sm:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?i-sm:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "i-sm",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "sm",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:(?i:))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?i:(?i:))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?i:(?i:))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?i:(?i:))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?i:(?i:))",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 10,
+                      "raw": "(?i:)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 10,
+                          "raw": "(?i:)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 7,
+                            "end": 8,
+                            "raw": "i",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "i",
+                              "ignoreCase": true,
+                              "multiline": false,
+                              "dotAll": false
+                            },
+                            "remove": null
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 9,
+                              "raw": "",
+                              "elements": []
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/(?i:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "(?i:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(?i:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "(?i:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?i:)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "(?i:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(?i:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "(?i:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:.es)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?i:.es)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?i:.es)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?i:.es)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?i:.es)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": ".es",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:.es)/s": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?i:.es)/s",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?i:.es)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?i:.es)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?i:.es)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": ".es",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "s",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:Z\\B)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?i:Z\\B)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?i:Z\\B)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?i:Z\\B)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?i:Z\\B)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "Z\\B",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "Z",
+                          "value": 90
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\B",
+                          "kind": "word",
+                          "negate": true
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:[^ab])c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?i:[^ab])c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(?i:[^ab])c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(?i:[^ab])c",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?i:[^ab])",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 10,
+                      "raw": "[^ab]",
+                      "elements": [
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 10,
+                          "raw": "[^ab]",
+                          "unicodeSets": false,
+                          "negate": true,
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "a",
+                              "value": 97
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 8,
+                              "end": 9,
+                              "raw": "b",
+                              "value": 98
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:[ab])c/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?i:[ab])c/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?i:[ab])c",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?i:[ab])c",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?i:[ab])",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "[ab]",
+                      "elements": [
+                        {
+                          "type": "CharacterClass",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 9,
+                          "raw": "[ab]",
+                          "unicodeSets": false,
+                          "negate": false,
+                          "elements": [
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "a",
+                              "value": 97
+                            },
+                            {
+                              "type": "Character",
+                              "parent": "♻️../..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "b",
+                              "value": 98
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "c",
+                  "value": 99
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:\\P{Lu})/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?i:\\P{Lu})/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(?i:\\P{Lu})",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(?i:\\P{Lu})",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "(?i:\\P{Lu})",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 11,
+                      "raw": "\\P{Lu}",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 11,
+                          "raw": "\\P{Lu}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Lu",
+                          "negate": true
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:\\W)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?i:\\W)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?i:\\W)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?i:\\W)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?i:\\W)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "\\W",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:\\b)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?i:\\b)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?i:\\b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?i:\\b)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?i:\\b)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "\\b",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\b",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:\\b)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?i:\\b)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?i:\\b)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?i:\\b)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?i:\\b)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "\\b",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\b",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:\\p{Lu})/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?i:\\p{Lu})/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(?i:\\p{Lu})",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(?i:\\p{Lu})",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "(?i:\\p{Lu})",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 11,
+                      "raw": "\\p{Lu}",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 11,
+                          "raw": "\\p{Lu}",
+                          "kind": "property",
+                          "strings": false,
+                          "key": "General_Category",
+                          "value": "Lu",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:\\u0061)b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?i:\\u0061)b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?i:\\u0061)b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?i:\\u0061)b",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "(?i:\\u0061)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 11,
+                      "raw": "\\u0061",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 11,
+                          "raw": "\\u0061",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:\\u{0061})b/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?i:\\u{0061})b/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(?i:\\u{0061})b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?i:\\u{0061})b",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?i:\\u{0061})",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 13,
+                      "raw": "\\u{0061}",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 13,
+                          "raw": "\\u{0061}",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:\\w)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?i:\\w)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?i:\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?i:\\w)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?i:\\w)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:\\w)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?i:\\w)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?i:\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?i:\\w)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?i:\\w)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:\\x61)b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?i:\\x61)b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?i:\\x61)b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?i:\\x61)b",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?i:\\x61)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "\\x61",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 9,
+                          "raw": "\\x61",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:a)b/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?i:a)b/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?i:a)b",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?i:a)b",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?i:a)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "b",
+                  "value": 98
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:aB)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?i:aB)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?i:aB)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?i:aB)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?i:aB)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "aB",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "B",
+                          "value": 66
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:es$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?i:es$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?i:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?i:es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?i:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?i:es$)/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?i:es$)/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?i:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?i:es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?i:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?ii-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?ii-:a)/: Duplicated flag 'i'",
+        "index": 3
+      }
+    },
+    "/(?ii:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?ii:a)/: Duplicated flag 'i'",
+        "index": 3
+      }
+    },
+    "/(?im-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?im-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?im-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?im-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?im-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "im-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "im",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?im-s:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?im-s:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?im-s:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?im-s:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?im-s:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "im-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "im",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?im:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?im:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?im:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?im:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?im:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "im",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "im",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?ims-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?ims-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?ims-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?ims-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?ims-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "ims-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "ims",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?ims-m:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?ims-m:a)/: Duplicated flag 'm'",
+        "index": 8
+      }
+    },
+    "/(?ims:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?ims:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?ims:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?ims:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?ims:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "ims",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "ims",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?ims:)/ims": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?ims:)/ims",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?ims:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?ims:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?ims:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "ims",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "ims",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 12,
+          "raw": "ims",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?imsi-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?imsi-:a)/: Duplicated flag 'i'",
+        "index": 3
+      }
+    },
+    "/(?imsi:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?imsi:a)/: Duplicated flag 'i'",
+        "index": 3
+      }
+    },
+    "/(?is-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?is-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?is-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?is-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?is-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "is-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "is",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?is-m:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?is-m:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?is-m:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?is-m:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?is-m:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "is-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "is",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?is:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?is:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?is:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?is:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?is:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "is",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "is",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?ism-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?ism-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?ism-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?ism-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?ism-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "ism-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "ism",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?ism:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?ism:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?ism:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?ism:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?ism:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "ism",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "ism",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?iͥ-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?iͥ-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?iͥ:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?iͥ:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?m-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?m-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?m-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?m-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?m-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "m-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m-:es$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?m-:es$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?m-:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?m-:es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?m-:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "m-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m-:es$)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?m-:es$)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?m-:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?m-:es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?m-:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "m-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m-:es$|(?-m:js$))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?m-:es$|(?-m:js$))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?m-:es$|(?-m:js$))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(?m-:es$|(?-m:js$))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 20,
+                  "raw": "(?m-:es$|(?-m:js$))",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "m-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 19,
+                      "raw": "(?-m:js$)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 19,
+                          "raw": "(?-m:js$)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 12,
+                            "end": 14,
+                            "raw": "-m",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 12,
+                              "end": 12,
+                              "raw": "",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": false
+                            },
+                            "remove": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 13,
+                              "end": 14,
+                              "raw": "m",
+                              "ignoreCase": false,
+                              "multiline": true,
+                              "dotAll": false
+                            }
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 15,
+                              "end": 18,
+                              "raw": "js$",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 15,
+                                  "end": 16,
+                                  "raw": "j",
+                                  "value": 106
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 16,
+                                  "end": 17,
+                                  "raw": "s",
+                                  "value": 115
+                                },
+                                {
+                                  "type": "Assertion",
+                                  "parent": "♻️../..",
+                                  "start": 17,
+                                  "end": 18,
+                                  "raw": "$",
+                                  "kind": "end"
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m-:es.$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?m-:es.$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?m-:es.$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?m-:es.$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?m-:es.$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "m-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": "es.$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m-:es.$)/s": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?m-:es.$)/s",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?m-:es.$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?m-:es.$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?m-:es.$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "m-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": "es.$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "s",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m-i:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?m-i:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?m-i:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?m-i:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?m-i:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "m-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m-i:^a$)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?m-i:^a$)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?m-i:^a$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?m-i:^a$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?m-i:^a$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "m-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 10,
+                      "raw": "^a$",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m-ims:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?m-ims:a)/: Duplicated flag 'm'",
+        "index": 8
+      }
+    },
+    "/(?m-is:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?m-is:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?m-is:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?m-is:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?m-is:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "m-is",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "is",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m-m:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?m-m:a)/: Duplicated flag 'm'",
+        "index": 6
+      }
+    },
+    "/(?m-s:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?m-s:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?m-s:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?m-s:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?m-s:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "m-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m-si:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?m-si:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?m-si:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?m-si:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?m-si:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "m-si",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "si",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m:(?m:))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?m:(?m:))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?m:(?m:))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?m:(?m:))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?m:(?m:))",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 10,
+                      "raw": "(?m:)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 10,
+                          "raw": "(?m:)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 7,
+                            "end": 8,
+                            "raw": "m",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "m",
+                              "ignoreCase": false,
+                              "multiline": true,
+                              "dotAll": false
+                            },
+                            "remove": null
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 9,
+                              "raw": "",
+                              "elements": []
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/(?m:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "(?m:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(?m:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "(?m:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m:)/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?m:)/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "(?m:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(?m:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "(?m:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m:^(?-i:a)$)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?m:^(?-i:a)$)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(?m:^(?-i:a)$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?m:^(?-i:a)$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?m:^(?-i:a)$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 14,
+                      "raw": "^(?-i:a)$",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 13,
+                          "raw": "(?-i:a)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 8,
+                            "end": 10,
+                            "raw": "-i",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 8,
+                              "end": 8,
+                              "raw": "",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": false
+                            },
+                            "remove": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "i",
+                              "ignoreCase": true,
+                              "multiline": false,
+                              "dotAll": false
+                            }
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "a",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "a",
+                                  "value": 97
+                                }
+                              ]
+                            }
+                          ]
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m:es$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?m:es$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?m:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?m:es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?m:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m:es$)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?m:es$)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?m:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?m:es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?m:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m:es$)/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?m:es$)/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?m:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?m:es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?m:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m:es$|(?-m:js$))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(?m:es$|(?-m:js$))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?m:es$|(?-m:js$))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?m:es$|(?-m:js$))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 19,
+                  "raw": "(?m:es$|(?-m:js$))",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 18,
+                      "raw": "(?-m:js$)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 18,
+                          "raw": "(?-m:js$)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 11,
+                            "end": 13,
+                            "raw": "-m",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 11,
+                              "end": 11,
+                              "raw": "",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": false
+                            },
+                            "remove": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 12,
+                              "end": 13,
+                              "raw": "m",
+                              "ignoreCase": false,
+                              "multiline": true,
+                              "dotAll": false
+                            }
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 14,
+                              "end": 17,
+                              "raw": "js$",
+                              "elements": [
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 14,
+                                  "end": 15,
+                                  "raw": "j",
+                                  "value": 106
+                                },
+                                {
+                                  "type": "Character",
+                                  "parent": "♻️../..",
+                                  "start": 15,
+                                  "end": 16,
+                                  "raw": "s",
+                                  "value": 115
+                                },
+                                {
+                                  "type": "Assertion",
+                                  "parent": "♻️../..",
+                                  "start": 16,
+                                  "end": 17,
+                                  "raw": "$",
+                                  "kind": "end"
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 20,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m:es.$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?m:es.$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?m:es.$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?m:es.$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?m:es.$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "es.$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?m:es.$)/s": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?m:es.$)/s",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?m:es.$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?m:es.$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?m:es.$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": "es.$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "s",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?mi-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?mi-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?mi-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?mi-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?mi-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "mi-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "mi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?mi-s:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?mi-s:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?mi-s:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?mi-s:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?mi-s:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "mi-s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "mi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?mi:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?mi:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?mi:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?mi:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?mi:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "mi",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "mi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?mis-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?mis-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?mis-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?mis-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?mis-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "mis-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "mis",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?mis:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?mis:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?mis:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?mis:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?mis:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "mis",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "mis",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?ms-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?ms-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?ms-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?ms-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?ms-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "ms-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "ms",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?ms-i)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?ms-i)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?ms-i:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?ms-i:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?ms-i:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?ms-i:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?ms-i:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "ms-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "ms",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?ms:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?ms:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?ms:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?ms:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?ms:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "ms",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "ms",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?msi-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?msi-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?msi-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?msi-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?msi-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "msi-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "msi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?msi:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?msi:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?msi:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?msi:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?msi:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "msi",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "msi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?mͫ-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?mͫ-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?mͫ:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?mͫ:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?s\u0000-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s\u0000-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?s\u0000:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s\u0000:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?s-:(?-s:^.$))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?s-:(?-s:^.$))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?s-:(?-s:^.$))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?s-:(?-s:^.$))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 16,
+                  "raw": "(?s-:(?-s:^.$))",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "s-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 15,
+                      "raw": "(?-s:^.$)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 15,
+                          "raw": "(?-s:^.$)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 8,
+                            "end": 10,
+                            "raw": "-s",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 8,
+                              "end": 8,
+                              "raw": "",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": false
+                            },
+                            "remove": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "s",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": true
+                            }
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 11,
+                              "end": 14,
+                              "raw": "^.$",
+                              "elements": [
+                                {
+                                  "type": "Assertion",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": "^",
+                                  "kind": "start"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "Assertion",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 14,
+                                  "raw": "$",
+                                  "kind": "end"
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?s-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?s-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?s-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?s-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "s-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s-:.es$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?s-:.es$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?s-:.es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?s-:.es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?s-:.es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "s-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": ".es$",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s-:.es$)/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?s-:.es$)/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?s-:.es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?s-:.es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?s-:.es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "s-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": ".es$",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s-:.es)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?s-:.es)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?s-:.es)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?s-:.es)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?s-:.es)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "s-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": ".es",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s-:.es)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?s-:.es)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?s-:.es)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?s-:.es)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?s-:.es)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "s-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": ".es",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s-:^.$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?s-:^.$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?s-:^.$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?s-:^.$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?s-:^.$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "s-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "^.$",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s-\\u{0073}:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s-\\u{0073}:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?s-i:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?s-i:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?s-i:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?s-i:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?s-i:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "s-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s-im:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?s-im:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?s-im:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?s-im:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?s-im:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "s-im",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "im",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s-m:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?s-m:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?s-m:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?s-m:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?s-m:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "s-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s-mi:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?s-mi:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?s-mi:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?s-mi:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?s-mi:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "s-mi",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 7,
+                      "raw": "mi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s-s:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s-s:a)/: Duplicated flag 's'",
+        "index": 6
+      }
+    },
+    "/(?s:(?-s:^.$))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(?s:(?-s:^.$))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(?s:(?-s:^.$))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?s:(?-s:^.$))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?s:(?-s:^.$))",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 14,
+                      "raw": "(?-s:^.$)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 14,
+                          "raw": "(?-s:^.$)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 7,
+                            "end": 9,
+                            "raw": "-s",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 7,
+                              "end": 7,
+                              "raw": "",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": false
+                            },
+                            "remove": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 8,
+                              "end": 9,
+                              "raw": "s",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": true
+                            }
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 10,
+                              "end": 13,
+                              "raw": "^.$",
+                              "elements": [
+                                {
+                                  "type": "Assertion",
+                                  "parent": "♻️../..",
+                                  "start": 10,
+                                  "end": 11,
+                                  "raw": "^",
+                                  "kind": "start"
+                                },
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 11,
+                                  "end": 12,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "Assertion",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": "$",
+                                  "kind": "end"
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s:(?s:))/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?s:(?s:))/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?s:(?s:))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?s:(?s:))",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?s:(?s:))",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 10,
+                      "raw": "(?s:)",
+                      "elements": [
+                        {
+                          "type": "Group",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 10,
+                          "raw": "(?s:)",
+                          "modifiers": {
+                            "type": "Modifiers",
+                            "parent": "♻️..",
+                            "start": 7,
+                            "end": 8,
+                            "raw": "s",
+                            "add": {
+                              "type": "ModifierFlags",
+                              "parent": "♻️..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "s",
+                              "ignoreCase": false,
+                              "multiline": false,
+                              "dotAll": true
+                            },
+                            "remove": null
+                          },
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 9,
+                              "end": 9,
+                              "raw": "",
+                              "elements": []
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/(?s:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "(?s:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(?s:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "(?s:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s:)/s": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?s:)/s",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "(?s:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "(?s:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "(?s:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 5,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "s",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s:.es$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?s:.es$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?s:.es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?s:.es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?s:.es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": ".es$",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s:.es$)/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?s:.es$)/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?s:.es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?s:.es$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?s:.es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 9,
+                      "raw": ".es$",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s:.es)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?s:.es)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?s:.es)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?s:.es)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?s:.es)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": ".es",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s:.es)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?s:.es)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?s:.es)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?s:.es)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?s:.es)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": ".es",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "s",
+                          "value": 115
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s:^.$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?s:^.$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?s:^.$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?s:^.$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?s:^.$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "^.$",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s:^.$)/s": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?s:^.$)/s",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?s:^.$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?s:^.$)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?s:^.$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 4,
+                    "raw": "s",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "s",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 5,
+                      "end": 8,
+                      "raw": "^.$",
+                      "elements": [
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 6,
+                          "raw": "^",
+                          "kind": "start"
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "s",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?si-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?si-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?si-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?si-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?si-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "si-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "si",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?si-m:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?si-m:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?si-m:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?si-m:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?si-m:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "si-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "si",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?si:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?si:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?si:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?si:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?si:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "si",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "si",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?sim-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?sim-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?sim-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?sim-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?sim-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "sim-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "sim",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?sim:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?sim:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?sim:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?sim:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?sim:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "sim",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "sim",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?sm-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?sm-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?sm-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?sm-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?sm-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "sm-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "sm",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?sm-i:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?sm-i:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?sm-i:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?sm-i:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?sm-i:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "sm-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "sm",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?sm:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/(?sm:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 7,
+          "raw": "(?sm:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 7,
+              "raw": "(?sm:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(?sm:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 5,
+                    "raw": "sm",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 5,
+                      "raw": "sm",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 8,
+          "end": 8,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?smi-:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?smi-:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?smi-:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?smi-:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?smi-:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 7,
+                    "raw": "smi-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "smi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?smi:)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?smi:)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?smi:)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?smi:)",
+              "elements": [
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?smi:)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 3,
+                    "end": 6,
+                    "raw": "smi",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 6,
+                      "raw": "smi",
+                      "ignoreCase": true,
+                      "multiline": true,
+                      "dotAll": true
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 7,
+                      "raw": "",
+                      "elements": []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?s̀-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s̀-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?s̀:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s̀:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?s‌-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s‌-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?s‌:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s‌:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?s‍-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s‍-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?s‍:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s‍:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?s‎-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s‎-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?s‎:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s‎:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?s-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?s:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?s:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?u-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?u-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?u:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?u:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?y-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?y-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?y:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?y:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?İ-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?İ-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?İ:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?İ:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?ſ-:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?ſ-:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(?ſ:a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?ſ:a)/: Invalid group",
+        "index": 2
+      }
+    },
+    "/(a)(?-i:\\1)/i": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(a)(?-i:\\1)/i",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(a)(?-i:\\1)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(a)(?-i:\\1)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1/alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 12,
+                  "raw": "(?-i:\\1)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 8,
+                    "raw": "-i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 6,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 11,
+                      "raw": "\\1",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 11,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "i",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(a)(?i-:\\1)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(a)(?i-:\\1)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "(a)(?i-:\\1)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "(a)(?i-:\\1)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1/alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 12,
+                  "raw": "(?i-:\\1)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 8,
+                    "raw": "i-",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 8,
+                      "end": 8,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 11,
+                      "raw": "\\1",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 11,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(a)(?i:\\1)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(a)(?i:\\1)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(a)(?i:\\1)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(a)(?i:\\1)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1/alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 11,
+                  "raw": "(?i:\\1)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 6,
+                    "end": 7,
+                    "raw": "i",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "i",
+                      "ignoreCase": true,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": null
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 10,
+                      "raw": "\\1",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 10,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^(?-m:es$)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^(?-m:es$)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^(?-m:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^(?-m:es$)",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "(?-m:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 4,
+                    "end": 6,
+                    "raw": "-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 4,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 10,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^(?-m:es$)/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^(?-m:es$)/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^(?-m:es$)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^(?-m:es$)",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Group",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "(?-m:es$)",
+                  "modifiers": {
+                    "type": "Modifiers",
+                    "parent": "♻️..",
+                    "start": 4,
+                    "end": 6,
+                    "raw": "-m",
+                    "add": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 4,
+                      "end": 4,
+                      "raw": "",
+                      "ignoreCase": false,
+                      "multiline": false,
+                      "dotAll": false
+                    },
+                    "remove": {
+                      "type": "ModifierFlags",
+                      "parent": "♻️..",
+                      "start": 5,
+                      "end": 6,
+                      "raw": "m",
+                      "ignoreCase": false,
+                      "multiline": true,
+                      "dotAll": false
+                    }
+                  },
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 10,
+                      "raw": "es$",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "e",
+                          "value": 101
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "s",
+                          "value": 115
+                        },
+                        {
+                          "type": "Assertion",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "$",
+                          "kind": "end"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/regexp-named-groups.json b/test/fixtures/parser/literal/test262/regexp-named-groups.json
new file mode 100644
index 0000000..5e03c4b
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/regexp-named-groups.json
@@ -0,0 +1,13300 @@
+{
+  "_test262FileNames": [
+    "test/annexB/built-ins/RegExp/named-groups/non-unicode-malformed.js",
+    "test/built-ins/RegExp/named-groups/groups-object-unmatched.js",
+    "test/built-ins/RegExp/named-groups/groups-object.js",
+    "test/built-ins/RegExp/named-groups/groups-properties.js",
+    "test/built-ins/RegExp/named-groups/non-unicode-match.js",
+    "test/built-ins/RegExp/named-groups/non-unicode-property-names-valid.js",
+    "test/built-ins/RegExp/named-groups/non-unicode-property-names.js",
+    "test/built-ins/RegExp/named-groups/non-unicode-references.js",
+    "test/built-ins/RegExp/named-groups/unicode-match.js",
+    "test/built-ins/RegExp/named-groups/unicode-property-names-valid.js",
+    "test/built-ins/RegExp/named-groups/unicode-property-names.js",
+    "test/built-ins/RegExp/named-groups/unicode-references.js",
+    "test/language/literals/regexp/named-groups/forward-reference.js",
+    "test/language/literals/regexp/named-groups/invalid-dangling-groupname-2-u.js",
+    "test/language/literals/regexp/named-groups/invalid-dangling-groupname-2.js",
+    "test/language/literals/regexp/named-groups/invalid-dangling-groupname-3-u.js",
+    "test/language/literals/regexp/named-groups/invalid-dangling-groupname-3.js",
+    "test/language/literals/regexp/named-groups/invalid-dangling-groupname-4-u.js",
+    "test/language/literals/regexp/named-groups/invalid-dangling-groupname-4.js",
+    "test/language/literals/regexp/named-groups/invalid-dangling-groupname-5.js",
+    "test/language/literals/regexp/named-groups/invalid-dangling-groupname-u.js",
+    "test/language/literals/regexp/named-groups/invalid-dangling-groupname.js",
+    "test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier-2-u.js",
+    "test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier-2.js",
+    "test/language/literals/regexp/named-groups/invalid-empty-groupspecifier-u.js",
+    "test/language/literals/regexp/named-groups/invalid-empty-groupspecifier.js",
+    "test/language/literals/regexp/named-groups/invalid-identity-escape-in-capture-u.js",
+    "test/language/literals/regexp/named-groups/invalid-incomplete-groupname-2-u.js",
+    "test/language/literals/regexp/named-groups/invalid-incomplete-groupname-2.js",
+    "test/language/literals/regexp/named-groups/invalid-incomplete-groupname-3-u.js",
+    "test/language/literals/regexp/named-groups/invalid-incomplete-groupname-3.js",
+    "test/language/literals/regexp/named-groups/invalid-incomplete-groupname-4.js",
+    "test/language/literals/regexp/named-groups/invalid-incomplete-groupname-5.js",
+    "test/language/literals/regexp/named-groups/invalid-incomplete-groupname-6.js",
+    "test/language/literals/regexp/named-groups/invalid-incomplete-groupname-u.js",
+    "test/language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-2-u.js",
+    "test/language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-u.js",
+    "test/language/literals/regexp/named-groups/invalid-incomplete-groupname.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier-4-u.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier-4.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-2-u.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-2.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-3.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-4-u.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-4.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-5-u.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-5.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-6.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-7.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-8-u.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-8.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-9-u.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-u.js",
+    "test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier.js",
+    "test/language/literals/regexp/named-groups/invalid-numeric-groupspecifier-u.js",
+    "test/language/literals/regexp/named-groups/invalid-numeric-groupspecifier.js",
+    "test/language/literals/regexp/named-groups/invalid-punctuator-starting-groupspecifier-u.js",
+    "test/language/literals/regexp/named-groups/invalid-punctuator-starting-groupspecifier.js",
+    "test/language/literals/regexp/named-groups/invalid-punctuator-within-groupspecifier-u.js",
+    "test/language/literals/regexp/named-groups/invalid-punctuator-within-groupspecifier.js",
+    "test/language/literals/regexp/named-groups/invalid-unterminated-groupspecifier-u.js",
+    "test/language/literals/regexp/named-groups/invalid-unterminated-groupspecifier.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/(.)(?<a>a)(?<b>\\1)(\\2)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/(.)(?<a>a)(?<b>\\1)(\\2)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "(.)(?<a>a)(?<b>\\1)(\\2)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "(.)(?<a>a)(?<b>\\1)(\\2)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2/alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 11,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 10,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3/alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 19,
+                  "raw": "(?<b>\\1)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 18,
+                      "raw": "\\1",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 18,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 23,
+                  "raw": "(\\2)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 20,
+                      "end": 22,
+                      "raw": "\\2",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 22,
+                          "raw": "\\2",
+                          "ref": 2,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../1"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 24,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.)(?<a>a)(?<b>\\1)(\\2)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/(.)(?<a>a)(?<b>\\1)(\\2)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "(.)(?<a>a)(?<b>\\1)(\\2)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "(.)(?<a>a)(?<b>\\1)(\\2)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2/alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 11,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 10,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3/alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 19,
+                  "raw": "(?<b>\\1)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 18,
+                      "raw": "\\1",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 18,
+                          "raw": "\\1",
+                          "ref": 1,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 23,
+                  "raw": "(\\2)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 20,
+                      "end": 22,
+                      "raw": "\\2",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 22,
+                          "raw": "\\2",
+                          "ref": 2,
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../1"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.)(?<a>a)\\1\\2/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(.)(?<a>a)\\1\\2/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(.)(?<a>a)\\1\\2",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(.)(?<a>a)\\1\\2",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 11,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 10,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 13,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 15,
+                  "raw": "\\2",
+                  "ref": 2,
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 16,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(.)(?<a>a)\\1\\2/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(.)(?<a>a)\\1\\2/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(.)(?<a>a)\\1\\2",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(.)(?<a>a)\\1\\2",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 11,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 10,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 13,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 15,
+                  "raw": "\\2",
+                  "ref": 2,
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<$>a)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?<$>a)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<$>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<$>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<$>a)",
+                  "name": "$",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<$>a)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?<$>a)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<$>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<$>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<$>a)",
+                  "name": "$",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<$❞>a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<$❞>a)/: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/(?<$𐒤>a)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?<$𐒤>a)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<$𐒤>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<$𐒤>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<$𐒤>a)",
+                  "name": "$𐒤",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<42a>a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<42a>a)/: Invalid capture group name",
+        "index": 4
+      }
+    },
+    "/(?<42a>a)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<42a>a)/u: Invalid capture group name",
+        "index": 4
+      }
+    },
+    "/(?<:a>a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<:a>a)/: Invalid capture group name",
+        "index": 4
+      }
+    },
+    "/(?<:a>a)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<:a>a)/u: Invalid capture group name",
+        "index": 4
+      }
+    },
+    "/(?<>a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<>a)/: Invalid capture group name",
+        "index": 4
+      }
+    },
+    "/(?<>a)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<>a)/u: Invalid capture group name",
+        "index": 4
+      }
+    },
+    "/(?<\\>.)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<\\>.)/: Invalid capture group name",
+        "index": 4
+      }
+    },
+    "/(?<\\>.)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<\\>.)/u: Invalid capture group name",
+        "index": 4
+      }
+    },
+    "/(?<\\u0041>.)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?<\\u0041>.)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<\\u0041>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<\\u0041>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?<\\u0041>.)",
+                  "name": "A",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 12,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u0041>.)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?<\\u0041>.)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<\\u0041>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<\\u0041>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?<\\u0041>.)",
+                  "name": "A",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 12,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\ud835\\udcd1\\ud835\\udcfb\\ud835\\udcf8\\ud835\\udd00\\ud835\\udcf7>brown)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 72,
+        "raw": "/(?<\\ud835\\udcd1\\ud835\\udcfb\\ud835\\udcf8\\ud835\\udd00\\ud835\\udcf7>brown)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 71,
+          "raw": "(?<\\ud835\\udcd1\\ud835\\udcfb\\ud835\\udcf8\\ud835\\udd00\\ud835\\udcf7>brown)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 71,
+              "raw": "(?<\\ud835\\udcd1\\ud835\\udcfb\\ud835\\udcf8\\ud835\\udd00\\ud835\\udcf7>brown)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 71,
+                  "raw": "(?<\\ud835\\udcd1\\ud835\\udcfb\\ud835\\udcf8\\ud835\\udd00\\ud835\\udcf7>brown)",
+                  "name": "𝓑𝓻𝓸𝔀𝓷",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 65,
+                      "end": 70,
+                      "raw": "brown",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 65,
+                          "end": 66,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 66,
+                          "end": 67,
+                          "raw": "r",
+                          "value": 114
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 67,
+                          "end": 68,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 68,
+                          "end": 69,
+                          "raw": "w",
+                          "value": 119
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 69,
+                          "end": 70,
+                          "raw": "n",
+                          "value": 110
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 72,
+          "end": 72,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\ud835\\udcd1\\ud835\\udcfb\\ud835\\udcf8\\ud835\\udd00\\ud835\\udcf7>brown)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 73,
+        "raw": "/(?<\\ud835\\udcd1\\ud835\\udcfb\\ud835\\udcf8\\ud835\\udd00\\ud835\\udcf7>brown)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 71,
+          "raw": "(?<\\ud835\\udcd1\\ud835\\udcfb\\ud835\\udcf8\\ud835\\udd00\\ud835\\udcf7>brown)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 71,
+              "raw": "(?<\\ud835\\udcd1\\ud835\\udcfb\\ud835\\udcf8\\ud835\\udd00\\ud835\\udcf7>brown)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 71,
+                  "raw": "(?<\\ud835\\udcd1\\ud835\\udcfb\\ud835\\udcf8\\ud835\\udd00\\ud835\\udcf7>brown)",
+                  "name": "𝓑𝓻𝓸𝔀𝓷",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 65,
+                      "end": 70,
+                      "raw": "brown",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 65,
+                          "end": 66,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 66,
+                          "end": 67,
+                          "raw": "r",
+                          "value": 114
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 67,
+                          "end": 68,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 68,
+                          "end": 69,
+                          "raw": "w",
+                          "value": 119
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 69,
+                          "end": 70,
+                          "raw": "n",
+                          "value": 110
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 72,
+          "end": 73,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u{0041}>.)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<\\u{0041}>.)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(?<\\u{0041}>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?<\\u{0041}>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<\\u{0041}>.)",
+                  "name": "A",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 14,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u{03C0}>a)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<\\u{03C0}>a)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "(?<\\u{03C0}>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "(?<\\u{03C0}>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<\\u{03C0}>a)",
+                  "name": "π",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 14,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u{1d4d1}\\u{1d4fb}\\u{1d4f8}\\u{1d500}\\u{1d4f7}>brown)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 57,
+        "raw": "/(?<\\u{1d4d1}\\u{1d4fb}\\u{1d4f8}\\u{1d500}\\u{1d4f7}>brown)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 56,
+          "raw": "(?<\\u{1d4d1}\\u{1d4fb}\\u{1d4f8}\\u{1d500}\\u{1d4f7}>brown)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 56,
+              "raw": "(?<\\u{1d4d1}\\u{1d4fb}\\u{1d4f8}\\u{1d500}\\u{1d4f7}>brown)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 56,
+                  "raw": "(?<\\u{1d4d1}\\u{1d4fb}\\u{1d4f8}\\u{1d500}\\u{1d4f7}>brown)",
+                  "name": "𝓑𝓻𝓸𝔀𝓷",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 50,
+                      "end": 55,
+                      "raw": "brown",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 50,
+                          "end": 51,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 51,
+                          "end": 52,
+                          "raw": "r",
+                          "value": 114
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 52,
+                          "end": 53,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 53,
+                          "end": 54,
+                          "raw": "w",
+                          "value": 119
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 54,
+                          "end": 55,
+                          "raw": "n",
+                          "value": 110
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 57,
+          "end": 57,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u{1d4d1}\\u{1d4fb}\\u{1d4f8}\\u{1d500}\\u{1d4f7}>brown)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 58,
+        "raw": "/(?<\\u{1d4d1}\\u{1d4fb}\\u{1d4f8}\\u{1d500}\\u{1d4f7}>brown)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 56,
+          "raw": "(?<\\u{1d4d1}\\u{1d4fb}\\u{1d4f8}\\u{1d500}\\u{1d4f7}>brown)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 56,
+              "raw": "(?<\\u{1d4d1}\\u{1d4fb}\\u{1d4f8}\\u{1d500}\\u{1d4f7}>brown)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 56,
+                  "raw": "(?<\\u{1d4d1}\\u{1d4fb}\\u{1d4f8}\\u{1d500}\\u{1d4f7}>brown)",
+                  "name": "𝓑𝓻𝓸𝔀𝓷",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 50,
+                      "end": 55,
+                      "raw": "brown",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 50,
+                          "end": 51,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 51,
+                          "end": 52,
+                          "raw": "r",
+                          "value": 114
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 52,
+                          "end": 53,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 53,
+                          "end": 54,
+                          "raw": "w",
+                          "value": 119
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 54,
+                          "end": 55,
+                          "raw": "n",
+                          "value": 110
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 57,
+          "end": 58,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u{1d5b0}\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 48,
+        "raw": "/(?<\\u{1d5b0}\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 47,
+          "raw": "(?<\\u{1d5b0}\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 47,
+              "raw": "(?<\\u{1d5b0}\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 47,
+                  "raw": "(?<\\u{1d5b0}\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 32,
+                      "end": 46,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 32,
+                          "end": 33,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 33,
+                          "end": 36,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 33,
+                            "end": 35,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 36,
+                          "end": 38,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 38,
+                          "end": 41,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 38,
+                            "end": 40,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 41,
+                          "end": 43,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 43,
+                          "end": 46,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 43,
+                            "end": 45,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 48,
+          "end": 48,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u{1d5b0}\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 49,
+        "raw": "/(?<\\u{1d5b0}\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 47,
+          "raw": "(?<\\u{1d5b0}\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 47,
+              "raw": "(?<\\u{1d5b0}\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 47,
+                  "raw": "(?<\\u{1d5b0}\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 32,
+                      "end": 46,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 32,
+                          "end": 33,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 33,
+                          "end": 36,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 33,
+                            "end": 35,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 36,
+                          "end": 38,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 38,
+                          "end": 41,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 38,
+                            "end": 40,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 41,
+                          "end": 43,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 43,
+                          "end": 46,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 43,
+                            "end": 45,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 48,
+          "end": 49,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u{1d5b0}\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/(?<\\u{1d5b0}\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "(?<\\u{1d5b0}\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "(?<\\u{1d5b0}\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 40,
+                  "raw": "(?<\\u{1d5b0}\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 25,
+                      "end": 39,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 25,
+                          "end": 26,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 26,
+                          "end": 29,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 26,
+                            "end": 28,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 31,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 31,
+                          "end": 34,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 31,
+                            "end": 33,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 34,
+                          "end": 36,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 36,
+                          "end": 39,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 36,
+                            "end": 38,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 41,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u{1d5b0}\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 42,
+        "raw": "/(?<\\u{1d5b0}\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "(?<\\u{1d5b0}\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "(?<\\u{1d5b0}\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 40,
+                  "raw": "(?<\\u{1d5b0}\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 25,
+                      "end": 39,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 25,
+                          "end": 26,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 26,
+                          "end": 29,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 26,
+                            "end": 28,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 31,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 31,
+                          "end": 34,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 31,
+                            "end": 33,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 34,
+                          "end": 36,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 36,
+                          "end": 39,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 36,
+                            "end": 38,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 42,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u{1d5b0}𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/(?<\\u{1d5b0}𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "(?<\\u{1d5b0}𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "(?<\\u{1d5b0}𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 40,
+                  "raw": "(?<\\u{1d5b0}𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 25,
+                      "end": 39,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 25,
+                          "end": 26,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 26,
+                          "end": 29,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 26,
+                            "end": 28,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 31,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 31,
+                          "end": 34,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 31,
+                            "end": 33,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 34,
+                          "end": 36,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 36,
+                          "end": 39,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 36,
+                            "end": 38,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 41,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u{1d5b0}𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 42,
+        "raw": "/(?<\\u{1d5b0}𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "(?<\\u{1d5b0}𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "(?<\\u{1d5b0}𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 40,
+                  "raw": "(?<\\u{1d5b0}𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 25,
+                      "end": 39,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 25,
+                          "end": 26,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 26,
+                          "end": 29,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 26,
+                            "end": 28,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 31,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 31,
+                          "end": 34,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 31,
+                            "end": 33,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 34,
+                          "end": 36,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 36,
+                          "end": 39,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 36,
+                            "end": 38,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 42,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u{1d5b0}𝖡𝖥>q\\w*\\W\\w*\\W\\w*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/(?<\\u{1d5b0}𝖡𝖥>q\\w*\\W\\w*\\W\\w*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "(?<\\u{1d5b0}𝖡𝖥>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "(?<\\u{1d5b0}𝖡𝖥>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 33,
+                  "raw": "(?<\\u{1d5b0}𝖡𝖥>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 32,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 22,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 19,
+                            "end": 21,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 24,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 24,
+                          "end": 27,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 24,
+                            "end": 26,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 27,
+                          "end": 29,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 32,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 29,
+                            "end": 31,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 34,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<\\u{1d5b0}𝖡𝖥>q\\w*\\W\\w*\\W\\w*)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/(?<\\u{1d5b0}𝖡𝖥>q\\w*\\W\\w*\\W\\w*)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "(?<\\u{1d5b0}𝖡𝖥>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "(?<\\u{1d5b0}𝖡𝖥>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 33,
+                  "raw": "(?<\\u{1d5b0}𝖡𝖥>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 32,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 22,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 19,
+                            "end": 21,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 24,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 24,
+                          "end": 27,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 24,
+                            "end": 26,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 27,
+                          "end": 29,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 32,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 29,
+                            "end": 31,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<_>a)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?<_>a)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<_>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<_>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<_>a)",
+                  "name": "_",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<_>a)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?<_>a)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<_>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<_>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<_>a)",
+                  "name": "_",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<_\\u200C>a)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?<_\\u200C>a)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?<_\\u200C>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?<_\\u200C>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<_\\u200C>a)",
+                  "name": "_‌",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 13,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<_\\u200C>a)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(?<_\\u200C>a)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?<_\\u200C>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?<_\\u200C>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<_\\u200C>a)",
+                  "name": "_‌",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 13,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<_\\u200D>a)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?<_\\u200D>a)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?<_\\u200D>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?<_\\u200D>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<_\\u200D>a)",
+                  "name": "_‍",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 13,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<_\\u200D>a)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(?<_\\u200D>a)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?<_\\u200D>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?<_\\u200D>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<_\\u200D>a)",
+                  "name": "_‍",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 12,
+                      "end": 13,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<__proto__>.)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<__proto__>.)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<__proto__>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<__proto__>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 16,
+                  "raw": "(?<__proto__>.)",
+                  "name": "__proto__",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 15,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a42>a)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?<a42>a)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<a42>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<a42>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<a42>a)",
+                  "name": "a42",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a42>a)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?<a42>a)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<a42>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<a42>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<a42>a)",
+                  "name": "a42",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a:>a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a:>a)/: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/(?<a:>a)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a:>a)/u: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/(?<a>.(?<b>.(?<c>.)))/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/(?<a>.(?<b>.(?<c>.)))/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "(?<a>.(?<b>.(?<c>.)))",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "(?<a>.(?<b>.(?<c>.)))",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 22,
+                  "raw": "(?<a>.(?<b>.(?<c>.)))",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 21,
+                      "raw": ".(?<b>.(?<c>.))",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        },
+                        {
+                          "type": "CapturingGroup",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 21,
+                          "raw": "(?<b>.(?<c>.))",
+                          "name": "b",
+                          "alternatives": [
+                            {
+                              "type": "Alternative",
+                              "parent": "♻️../..",
+                              "start": 12,
+                              "end": 20,
+                              "raw": ".(?<c>.)",
+                              "elements": [
+                                {
+                                  "type": "CharacterSet",
+                                  "parent": "♻️../..",
+                                  "start": 12,
+                                  "end": 13,
+                                  "raw": ".",
+                                  "kind": "any"
+                                },
+                                {
+                                  "type": "CapturingGroup",
+                                  "parent": "♻️../..",
+                                  "start": 13,
+                                  "end": 20,
+                                  "raw": "(?<c>.)",
+                                  "name": "c",
+                                  "alternatives": [
+                                    {
+                                      "type": "Alternative",
+                                      "parent": "♻️../..",
+                                      "start": 18,
+                                      "end": 19,
+                                      "raw": ".",
+                                      "elements": [
+                                        {
+                                          "type": "CharacterSet",
+                                          "parent": "♻️../..",
+                                          "start": 18,
+                                          "end": 19,
+                                          "raw": ".",
+                                          "kind": "any"
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "references": []
+                                }
+                              ]
+                            }
+                          ],
+                          "references": []
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>.)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../5"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 15,
+                  "raw": "(?<b>.)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 14,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../4"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 22,
+                  "raw": "(?<c>.)",
+                  "name": "c",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 20,
+                      "end": 21,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 21,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 27,
+                  "raw": "\\k<c>",
+                  "ref": "c",
+                  "ambiguous": false,
+                  "resolved": "♻️../2"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 32,
+                  "raw": "\\k<b>",
+                  "ref": "b",
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 37,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 38,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "(?<a>.)(?<b>.)(?<c>.)\\k<c>\\k<b>\\k<a>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>.)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../5"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 15,
+                  "raw": "(?<b>.)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 14,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../4"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 22,
+                  "raw": "(?<c>.)",
+                  "name": "c",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 20,
+                      "end": 21,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 21,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 27,
+                  "raw": "\\k<c>",
+                  "ref": "c",
+                  "ambiguous": false,
+                  "resolved": "♻️../2"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 32,
+                  "raw": "\\k<b>",
+                  "ref": "b",
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 37,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>.)\\k/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a>.)\\k/: Invalid named reference",
+        "index": 10
+      }
+    },
+    "/(?<a>.)\\k/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a>.)\\k/u: Invalid named reference",
+        "index": 10
+      }
+    },
+    "/(?<a>.)\\k<>/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a>.)\\k<>/: Invalid capture group name",
+        "index": 11
+      }
+    },
+    "/(?<a>.)\\k<>/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a>.)\\k<>/u: Invalid capture group name",
+        "index": 11
+      }
+    },
+    "/(?<a>.)\\k<a/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a>.)\\k<a/: Invalid capture group name",
+        "index": 12
+      }
+    },
+    "/(?<a>.)\\k<a/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a>.)\\k<a/u: Invalid capture group name",
+        "index": 12
+      }
+    },
+    "/(?<a>.)\\k<b>/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a>.)\\k<b>/: Invalid named capture referenced",
+        "index": 13
+      }
+    },
+    "/(?<a>.)\\k<b>/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a>.)\\k<b>/u: Invalid named capture referenced",
+        "index": 13
+      }
+    },
+    "/(?<a>\\a)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?<a>\\a)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(?<a>\\a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?<a>\\a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<a>\\a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 8,
+                      "raw": "\\a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>\\a)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a>\\a)/u: Invalid escape",
+        "index": 7
+      }
+    },
+    "/(?<a>\\k<a>\\w)../": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/(?<a>\\k<a>\\w)../",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<a>\\k<a>\\w)..",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<a>\\k<a>\\w)..",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<a>\\k<a>\\w)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 13,
+                      "raw": "\\k<a>\\w",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 11,
+                          "raw": "\\k<a>",
+                          "ref": "a",
+                          "ambiguous": false,
+                          "resolved": "♻️../../../.."
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 13,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>\\k<a>\\w)../u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?<a>\\k<a>\\w)../u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "(?<a>\\k<a>\\w)..",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "(?<a>\\k<a>\\w)..",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<a>\\k<a>\\w)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 13,
+                      "raw": "\\k<a>\\w",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 11,
+                          "raw": "\\k<a>",
+                          "ref": "a",
+                          "ambiguous": false,
+                          "resolved": "♻️../../../.."
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 13,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>\\w\\w)(?<b>\\w)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(?<a>\\w\\w)(?<b>\\w)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?<a>\\w\\w)(?<b>\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?<a>\\w\\w)(?<b>\\w)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?<a>\\w\\w)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 10,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 19,
+                  "raw": "(?<b>\\w)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 18,
+                      "raw": "\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 18,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 20,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>\\w\\w)(?<b>\\w)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?<a>\\w\\w)(?<b>\\w)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?<a>\\w\\w)(?<b>\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?<a>\\w\\w)(?<b>\\w)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 11,
+                  "raw": "(?<a>\\w\\w)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 10,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 10,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 19,
+                  "raw": "(?<b>\\w)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 18,
+                      "raw": "\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 18,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>\\w\\w\\w)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/(?<a>\\w\\w\\w)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<a>\\w\\w\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<a>\\w\\w\\w)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?<a>\\w\\w\\w)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 12,
+                      "raw": "\\w\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 10,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 12,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>\\w\\w\\w)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?<a>\\w\\w\\w)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<a>\\w\\w\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<a>\\w\\w\\w)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?<a>\\w\\w\\w)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 12,
+                      "raw": "\\w\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 10,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 12,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>a)(?<b>b)(?<a>a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a>a)(?<b>b)(?<a>a)/: Duplicate capture group name",
+        "index": 20
+      }
+    },
+    "/(?<a>a)(?<b>b)(?<a>a)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a>a)(?<b>b)(?<a>a)/u: Duplicate capture group name",
+        "index": 20
+      }
+    },
+    "/(?<a>a)(?<b>b)\\k<a>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?<a>a)(?<b>b)\\k<a>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?<a>a)(?<b>b)\\k<a>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(?<a>a)(?<b>b)\\k<a>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 15,
+                  "raw": "(?<b>b)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 14,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 20,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>a)(?<b>b)\\k<a>/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(?<a>a)(?<b>b)\\k<a>/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?<a>a)(?<b>b)\\k<a>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(?<a>a)(?<b>b)\\k<a>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 15,
+                  "raw": "(?<b>b)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 14,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 20,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>a)(?<b>b)\\k<a>|(?<c>c)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/(?<a>a)(?<b>b)\\k<a>|(?<c>c)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "(?<a>a)(?<b>b)\\k<a>|(?<c>c)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(?<a>a)(?<b>b)\\k<a>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 15,
+                  "raw": "(?<b>b)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 14,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 20,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 21,
+              "end": 28,
+              "raw": "(?<c>c)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 28,
+                  "raw": "(?<c>c)",
+                  "name": "c",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 26,
+                      "end": 27,
+                      "raw": "c",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 26,
+                          "end": 27,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 29,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>a)(?<b>b)\\k<a>|(?<c>c)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/(?<a>a)(?<b>b)\\k<a>|(?<c>c)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "(?<a>a)(?<b>b)\\k<a>|(?<c>c)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(?<a>a)(?<b>b)\\k<a>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 15,
+                  "raw": "(?<b>b)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 14,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 20,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 21,
+              "end": 28,
+              "raw": "(?<c>c)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 28,
+                  "raw": "(?<c>c)",
+                  "name": "c",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 26,
+                      "end": 27,
+                      "raw": "c",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 26,
+                          "end": 27,
+                          "raw": "c",
+                          "value": 99
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>a).|(?<x>x)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/(?<a>a).|(?<x>x)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "(?<a>a).|(?<x>x)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(?<a>a).",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 10,
+              "end": 17,
+              "raw": "(?<x>x)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 17,
+                  "raw": "(?<x>x)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 15,
+                      "end": 16,
+                      "raw": "x",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 16,
+                          "raw": "x",
+                          "value": 120
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 18,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>a)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?<a>a)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<a>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<a>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>a)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?<a>a)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<a>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<a>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a>a)\\k<ab>/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a>a)\\k<ab>/: Invalid named capture referenced",
+        "index": 14
+      }
+    },
+    "/(?<a>a)\\k<ab>/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a>a)\\k<ab>/u: Invalid named capture referenced",
+        "index": 14
+      }
+    },
+    "/(?<a\\>.)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a\\>.)/: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/(?<a\\>.)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a\\>.)/u: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/(?<a\\uD801>.)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a\\uD801>.)/: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/(?<a\\uD801>.)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a\\uD801>.)/u: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/(?<a\\uD801\\uDCA4>.)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(?<a\\uD801\\uDCA4>.)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?<a\\uD801\\uDCA4>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "(?<a\\uD801\\uDCA4>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 20,
+                  "raw": "(?<a\\uD801\\uDCA4>.)",
+                  "name": "a𐒤",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 19,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a\\uD83D\\uDF12>.)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a\\uD83D\\uDF12>.)/: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/(?<a\\uDCA4>.)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a\\uDCA4>.)/: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/(?<a\\uDCA4>.)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a\\uDCA4>.)/u: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/(?<a\\u{104A4}>.)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/(?<a\\u{104A4}>.)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "(?<a\\u{104A4}>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "(?<a\\u{104A4}>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 17,
+                  "raw": "(?<a\\u{104A4}>.)",
+                  "name": "a𐒤",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 15,
+                      "end": 16,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 16,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<a\\u{10FFFF}>.)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a\\u{10FFFF}>.)/: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/(?<a\\u{110000}>.)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a\\u{110000}>.)/u: Invalid unicode escape",
+        "index": 7
+      }
+    },
+    "/(?<a\\u{1F08B}>.)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<a\\u{1F08B}>.)/: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/(?<aa)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<aa)/: Invalid capture group name",
+        "index": 6
+      }
+    },
+    "/(?<aa)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<aa)/u: Invalid capture group name",
+        "index": 6
+      }
+    },
+    "/(?<ab>a)\\k<a>/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<ab>a)\\k<a>/: Invalid named capture referenced",
+        "index": 14
+      }
+    },
+    "/(?<ab>a)\\k<a>/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<ab>a)\\k<a>/u: Invalid named capture referenced",
+        "index": 14
+      }
+    },
+    "/(?<animal>fox|dog)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/(?<animal>fox|dog)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?<animal>fox|dog)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?<animal>fox|dog)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 19,
+                  "raw": "(?<animal>fox|dog)",
+                  "name": "animal",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 14,
+                      "raw": "fox",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "x",
+                          "value": 120
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 15,
+                      "end": 18,
+                      "raw": "dog",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 16,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 17,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": "g",
+                          "value": 103
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 20,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<animal>fox|dog)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/(?<animal>fox|dog)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "(?<animal>fox|dog)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "(?<animal>fox|dog)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 19,
+                  "raw": "(?<animal>fox|dog)",
+                  "name": "animal",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 14,
+                      "raw": "fox",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "x",
+                          "value": 120
+                        }
+                      ]
+                    },
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 15,
+                      "end": 18,
+                      "raw": "dog",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 16,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 17,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": "g",
+                          "value": 103
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<b>.).\\k<b>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?<b>.).\\k<b>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?<b>.).\\k<b>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?<b>.).\\k<b>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<b>.)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 14,
+                  "raw": "\\k<b>",
+                  "ref": "b",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<b>.).\\k<b>/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(?<b>.).\\k<b>/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?<b>.).\\k<b>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?<b>.).\\k<b>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<b>.)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 14,
+                  "raw": "\\k<b>",
+                  "ref": "b",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<b>b).\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?<b>b).\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?<b>b).\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?<b>b).\\1",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<b>b)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<b>b).\\1/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(?<b>b).\\1/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(?<b>b).\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(?<b>b).\\1",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<b>b)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2"
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 11,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<b>b)\\k<a>(?<a>a)\\k<b>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/(?<b>b)\\k<a>(?<a>a)\\k<b>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "(?<b>b)\\k<a>(?<a>a)\\k<b>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "(?<b>b)\\k<a>(?<a>a)\\k<b>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<b>b)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 13,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../2"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 20,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 19,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 25,
+                  "raw": "\\k<b>",
+                  "ref": "b",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 26,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<b>b)\\k<a>(?<a>a)\\k<b>/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/(?<b>b)\\k<a>(?<a>a)\\k<b>/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "(?<b>b)\\k<a>(?<a>a)\\k<b>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "(?<b>b)\\k<a>(?<a>a)\\k<b>",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<b>b)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 13,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../2"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 20,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 19,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../1"
+                  ]
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 25,
+                  "raw": "\\k<b>",
+                  "ref": "b",
+                  "ambiguous": false,
+                  "resolved": "♻️../0"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<dog>dog)(.*?)(\\k<dog>)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/(?<dog>dog)(.*?)(\\k<dog>)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "(?<dog>dog)(.*?)(\\k<dog>)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "(?<dog>dog)(.*?)(\\k<dog>)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "(?<dog>dog)",
+                  "name": "dog",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 11,
+                      "raw": "dog",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "g",
+                          "value": 103
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2/alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 17,
+                  "raw": "(.*?)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 16,
+                      "raw": ".*?",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 16,
+                          "raw": ".*?",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": false,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 13,
+                            "end": 14,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 26,
+                  "raw": "(\\k<dog>)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 25,
+                      "raw": "\\k<dog>",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 25,
+                          "raw": "\\k<dog>",
+                          "ref": "dog",
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 27,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<dog>dog)(.*?)(\\k<dog>)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/(?<dog>dog)(.*?)(\\k<dog>)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "(?<dog>dog)(.*?)(\\k<dog>)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "(?<dog>dog)(.*?)(\\k<dog>)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 12,
+                  "raw": "(?<dog>dog)",
+                  "name": "dog",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 11,
+                      "raw": "dog",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "g",
+                          "value": 103
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2/alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 17,
+                  "raw": "(.*?)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 13,
+                      "end": 16,
+                      "raw": ".*?",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 16,
+                          "raw": ".*?",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": false,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 13,
+                            "end": 14,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 26,
+                  "raw": "(\\k<dog>)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 25,
+                      "raw": "\\k<dog>",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 25,
+                          "raw": "\\k<dog>",
+                          "ref": "dog",
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<fst>.)|(?<snd>.)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(?<fst>.)|(?<snd>.)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "(?<fst>.)|(?<snd>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<fst>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<fst>.)",
+                  "name": "fst",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            },
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 11,
+              "end": 20,
+              "raw": "(?<snd>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 20,
+                  "raw": "(?<snd>.)",
+                  "name": "snd",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 19,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<gt>>)a/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?<gt>>)a/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<gt>>)a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<gt>>)a",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<gt>>)",
+                  "name": "gt",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": ">",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": ">",
+                          "value": 62
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<gt>>)a/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?<gt>>)a/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<gt>>)a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<gt>>)a",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<gt>>)",
+                  "name": "gt",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": ">",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": ">",
+                          "value": 62
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<lt><)a/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?<lt><)a/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<lt><)a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<lt><)a",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<lt><)",
+                  "name": "lt",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "<",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "<",
+                          "value": 60
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<lt><)a/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?<lt><)a/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<lt><)a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<lt><)a",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(?<lt><)",
+                  "name": "lt",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "<",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "<",
+                          "value": 60
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<the2>the)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?<the2>the)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "(?<the2>the)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "(?<the2>the)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 13,
+                  "raw": "(?<the2>the)",
+                  "name": "the2",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 12,
+                      "raw": "the",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": "t",
+                          "value": 116
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "h",
+                          "value": 104
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "e",
+                          "value": 101
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<the\\ud835\\udfda>the)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/(?<the\\ud835\\udfda>the)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "(?<the\\ud835\\udfda>the)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "(?<the\\ud835\\udfda>the)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 24,
+                  "raw": "(?<the\\ud835\\udfda>the)",
+                  "name": "the𝟚",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 20,
+                      "end": 23,
+                      "raw": "the",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 21,
+                          "raw": "t",
+                          "value": 116
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 21,
+                          "end": 22,
+                          "raw": "h",
+                          "value": 104
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 23,
+                          "raw": "e",
+                          "value": 101
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 25,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<the\\ud835\\udfda>the)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/(?<the\\ud835\\udfda>the)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "(?<the\\ud835\\udfda>the)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "(?<the\\ud835\\udfda>the)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 24,
+                  "raw": "(?<the\\ud835\\udfda>the)",
+                  "name": "the𝟚",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 20,
+                      "end": 23,
+                      "raw": "the",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 21,
+                          "raw": "t",
+                          "value": 116
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 21,
+                          "end": 22,
+                          "raw": "h",
+                          "value": 104
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 23,
+                          "raw": "e",
+                          "value": 101
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<the\\u{1d7da}>the)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(?<the\\u{1d7da}>the)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "(?<the\\u{1d7da}>the)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "(?<the\\u{1d7da}>the)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 21,
+                  "raw": "(?<the\\u{1d7da}>the)",
+                  "name": "the𝟚",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 17,
+                      "end": 20,
+                      "raw": "the",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": "t",
+                          "value": 116
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "h",
+                          "value": 104
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 20,
+                          "raw": "e",
+                          "value": 101
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 22,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<the\\u{1d7da}>the)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/(?<the\\u{1d7da}>the)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "(?<the\\u{1d7da}>the)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "(?<the\\u{1d7da}>the)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 21,
+                  "raw": "(?<the\\u{1d7da}>the)",
+                  "name": "the𝟚",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 17,
+                      "end": 20,
+                      "raw": "the",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": "t",
+                          "value": 116
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "h",
+                          "value": 104
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 20,
+                          "raw": "e",
+                          "value": 101
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<the𝟚>the)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/(?<the𝟚>the)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?<the𝟚>the)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?<the𝟚>the)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<the𝟚>the)",
+                  "name": "the𝟚",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 13,
+                      "raw": "the",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "t",
+                          "value": 116
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "h",
+                          "value": 104
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "e",
+                          "value": 101
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 15,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<the𝟚>the)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/(?<the𝟚>the)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "(?<the𝟚>the)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "(?<the𝟚>the)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 14,
+                  "raw": "(?<the𝟚>the)",
+                  "name": "the𝟚",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 13,
+                      "raw": "the",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "t",
+                          "value": 116
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "h",
+                          "value": 104
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "e",
+                          "value": 101
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<x>.)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?<x>.)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<x>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<x>.)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<x>.)",
+                  "name": "x",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<π>a)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/(?<π>a)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<π>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<π>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<π>a)",
+                  "name": "π",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<π>a)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(?<π>a)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "(?<π>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "(?<π>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "(?<π>a)",
+                  "name": "π",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<ಠ_ಠ>a)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(?<ಠ_ಠ>a)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<ಠ_ಠ>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<ಠ_ಠ>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<ಠ_ಠ>a)",
+                  "name": "ಠ_ಠ",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<ಠ_ಠ>a)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(?<ಠ_ಠ>a)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "(?<ಠ_ಠ>a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "(?<ಠ_ಠ>a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<ಠ_ಠ>a)",
+                  "name": "ಠ_ಠ",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 9,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<❤>a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<❤>a)/: Invalid capture group name",
+        "index": 4
+      }
+    },
+    "/(?<❤>a)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<❤>a)/u: Invalid capture group name",
+        "index": 4
+      }
+    },
+    "/(?<狗>dog)(.*?)(\\k<狗>)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/(?<狗>dog)(.*?)(\\k<狗>)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "(?<狗>dog)(.*?)(\\k<狗>)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "(?<狗>dog)(.*?)(\\k<狗>)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<狗>dog)",
+                  "name": "狗",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "dog",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "g",
+                          "value": 103
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2/alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 15,
+                  "raw": "(.*?)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 14,
+                      "raw": ".*?",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 14,
+                          "raw": ".*?",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": false,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 11,
+                            "end": 12,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 22,
+                  "raw": "(\\k<狗>)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 21,
+                      "raw": "\\k<狗>",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 21,
+                          "raw": "\\k<狗>",
+                          "ref": "狗",
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 23,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<狗>dog)(.*?)(\\k<狗>)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/(?<狗>dog)(.*?)(\\k<狗>)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "(?<狗>dog)(.*?)(\\k<狗>)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "(?<狗>dog)(.*?)(\\k<狗>)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<狗>dog)",
+                  "name": "狗",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "dog",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "g",
+                          "value": 103
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2/alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 15,
+                  "raw": "(.*?)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 14,
+                      "raw": ".*?",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 14,
+                          "raw": ".*?",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": false,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 11,
+                            "end": 12,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 22,
+                  "raw": "(\\k<狗>)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 21,
+                      "raw": "\\k<狗>",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 21,
+                          "raw": "\\k<狗>",
+                          "ref": "狗",
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<狸>fox).*(?<狗>dog)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(?<狸>fox).*(?<狗>dog)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "(?<狸>fox).*(?<狗>dog)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "(?<狸>fox).*(?<狗>dog)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<狸>fox)",
+                  "name": "狸",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "fox",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "x",
+                          "value": 120
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 12,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 10,
+                    "end": 11,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 21,
+                  "raw": "(?<狗>dog)",
+                  "name": "狗",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 17,
+                      "end": 20,
+                      "raw": "dog",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 20,
+                          "raw": "g",
+                          "value": 103
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 22,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<狸>fox).*(?<狗>dog)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/(?<狸>fox).*(?<狗>dog)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "(?<狸>fox).*(?<狗>dog)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "(?<狸>fox).*(?<狗>dog)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "(?<狸>fox)",
+                  "name": "狸",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 9,
+                      "raw": "fox",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "x",
+                          "value": 120
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 12,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 10,
+                    "end": 11,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 21,
+                  "raw": "(?<狗>dog)",
+                  "name": "狗",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 17,
+                      "end": 20,
+                      "raw": "dog",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 20,
+                          "raw": "g",
+                          "value": 103
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𐒤>a)/": {
+      "error": {
+        "message": "Invalid regular expression: /(?<𐒤>a)/: Invalid capture group name",
+        "index": 4
+      }
+    },
+    "/(?<𐒤>a)/u": {
+      "error": {
+        "message": "Invalid regular expression: /(?<𐒤>a)/u: Invalid capture group name",
+        "index": 4
+      }
+    },
+    "/(?<𝑓𝑜𝑥>fox).*(?<𝓓𝓸𝓰>dog)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/(?<𝑓𝑜𝑥>fox).*(?<𝓓𝓸𝓰>dog)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "(?<𝑓𝑜𝑥>fox).*(?<𝓓𝓸𝓰>dog)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "(?<𝑓𝑜𝑥>fox).*(?<𝓓𝓸𝓰>dog)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<𝑓𝑜𝑥>fox)",
+                  "name": "𝑓𝑜𝑥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 14,
+                      "raw": "fox",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "x",
+                          "value": 120
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 17,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 15,
+                    "end": 16,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 31,
+                  "raw": "(?<𝓓𝓸𝓰>dog)",
+                  "name": "𝓓𝓸𝓰",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 27,
+                      "end": 30,
+                      "raw": "dog",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 27,
+                          "end": 28,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 28,
+                          "end": 29,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 30,
+                          "raw": "g",
+                          "value": 103
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 32,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝑓𝑜𝑥>fox).*(?<𝓓𝓸𝓰>dog)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/(?<𝑓𝑜𝑥>fox).*(?<𝓓𝓸𝓰>dog)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "(?<𝑓𝑜𝑥>fox).*(?<𝓓𝓸𝓰>dog)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "(?<𝑓𝑜𝑥>fox).*(?<𝓓𝓸𝓰>dog)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<𝑓𝑜𝑥>fox)",
+                  "name": "𝑓𝑜𝑥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 14,
+                      "raw": "fox",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "f",
+                          "value": 102
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "x",
+                          "value": 120
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 17,
+                  "raw": ".*",
+                  "min": 0,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 15,
+                    "end": 16,
+                    "raw": ".",
+                    "kind": "any"
+                  }
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 31,
+                  "raw": "(?<𝓓𝓸𝓰>dog)",
+                  "name": "𝓓𝓸𝓰",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 27,
+                      "end": 30,
+                      "raw": "dog",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 27,
+                          "end": 28,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 28,
+                          "end": 29,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 30,
+                          "raw": "g",
+                          "value": 103
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝓑𝓻𝓸𝔀𝓷>brown)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/(?<𝓑𝓻𝓸𝔀𝓷>brown)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "(?<𝓑𝓻𝓸𝔀𝓷>brown)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "(?<𝓑𝓻𝓸𝔀𝓷>brown)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 21,
+                  "raw": "(?<𝓑𝓻𝓸𝔀𝓷>brown)",
+                  "name": "𝓑𝓻𝓸𝔀𝓷",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 15,
+                      "end": 20,
+                      "raw": "brown",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 16,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 17,
+                          "raw": "r",
+                          "value": 114
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "w",
+                          "value": 119
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 20,
+                          "raw": "n",
+                          "value": 110
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 22,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝓑𝓻𝓸𝔀𝓷>brown)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/(?<𝓑𝓻𝓸𝔀𝓷>brown)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "(?<𝓑𝓻𝓸𝔀𝓷>brown)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "(?<𝓑𝓻𝓸𝔀𝓷>brown)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 21,
+                  "raw": "(?<𝓑𝓻𝓸𝔀𝓷>brown)",
+                  "name": "𝓑𝓻𝓸𝔀𝓷",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 15,
+                      "end": 20,
+                      "raw": "brown",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 16,
+                          "raw": "b",
+                          "value": 98
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 17,
+                          "raw": "r",
+                          "value": 114
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 18,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "w",
+                          "value": 119
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 20,
+                          "raw": "n",
+                          "value": 110
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝓓𝓸𝓰>dog)(.*?)(\\k<𝓓𝓸𝓰>)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/(?<𝓓𝓸𝓰>dog)(.*?)(\\k<𝓓𝓸𝓰>)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "(?<𝓓𝓸𝓰>dog)(.*?)(\\k<𝓓𝓸𝓰>)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "(?<𝓓𝓸𝓰>dog)(.*?)(\\k<𝓓𝓸𝓰>)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<𝓓𝓸𝓰>dog)",
+                  "name": "𝓓𝓸𝓰",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 14,
+                      "raw": "dog",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "g",
+                          "value": 103
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2/alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 20,
+                  "raw": "(.*?)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 19,
+                      "raw": ".*?",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 19,
+                          "raw": ".*?",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": false,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 16,
+                            "end": 17,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 32,
+                  "raw": "(\\k<𝓓𝓸𝓰>)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 21,
+                      "end": 31,
+                      "raw": "\\k<𝓓𝓸𝓰>",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 21,
+                          "end": 31,
+                          "raw": "\\k<𝓓𝓸𝓰>",
+                          "ref": "𝓓𝓸𝓰",
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 33,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝓓𝓸𝓰>dog)(.*?)(\\k<𝓓𝓸𝓰>)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/(?<𝓓𝓸𝓰>dog)(.*?)(\\k<𝓓𝓸𝓰>)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "(?<𝓓𝓸𝓰>dog)(.*?)(\\k<𝓓𝓸𝓰>)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "(?<𝓓𝓸𝓰>dog)(.*?)(\\k<𝓓𝓸𝓰>)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 15,
+                  "raw": "(?<𝓓𝓸𝓰>dog)",
+                  "name": "𝓓𝓸𝓰",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 14,
+                      "raw": "dog",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "d",
+                          "value": 100
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 13,
+                          "raw": "o",
+                          "value": 111
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 13,
+                          "end": 14,
+                          "raw": "g",
+                          "value": 103
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../2/alternatives/0/elements/0"
+                  ]
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 20,
+                  "raw": "(.*?)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 16,
+                      "end": 19,
+                      "raw": ".*?",
+                      "elements": [
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 16,
+                          "end": 19,
+                          "raw": ".*?",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": false,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 16,
+                            "end": 17,
+                            "raw": ".",
+                            "kind": "any"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 32,
+                  "raw": "(\\k<𝓓𝓸𝓰>)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 21,
+                      "end": 31,
+                      "raw": "\\k<𝓓𝓸𝓰>",
+                      "elements": [
+                        {
+                          "type": "Backreference",
+                          "parent": "♻️../..",
+                          "start": 21,
+                          "end": 31,
+                          "raw": "\\k<𝓓𝓸𝓰>",
+                          "ref": "𝓓𝓸𝓰",
+                          "ambiguous": false,
+                          "resolved": "♻️../../../../../0"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝖰\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/(?<𝖰\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "(?<𝖰\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "(?<𝖰\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 40,
+                  "raw": "(?<𝖰\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 25,
+                      "end": 39,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 25,
+                          "end": 26,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 26,
+                          "end": 29,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 26,
+                            "end": 28,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 31,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 31,
+                          "end": 34,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 31,
+                            "end": 33,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 34,
+                          "end": 36,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 36,
+                          "end": 39,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 36,
+                            "end": 38,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 41,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝖰\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 42,
+        "raw": "/(?<𝖰\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "(?<𝖰\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "(?<𝖰\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 40,
+                  "raw": "(?<𝖰\\u{1d5a1}\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 25,
+                      "end": 39,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 25,
+                          "end": 26,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 26,
+                          "end": 29,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 26,
+                            "end": 28,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 31,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 31,
+                          "end": 34,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 31,
+                            "end": 33,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 34,
+                          "end": 36,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 36,
+                          "end": 39,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 36,
+                            "end": 38,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 42,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝖰\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/(?<𝖰\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "(?<𝖰\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "(?<𝖰\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 33,
+                  "raw": "(?<𝖰\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 32,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 22,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 19,
+                            "end": 21,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 24,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 24,
+                          "end": 27,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 24,
+                            "end": 26,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 27,
+                          "end": 29,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 32,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 29,
+                            "end": 31,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 34,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝖰\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/(?<𝖰\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "(?<𝖰\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "(?<𝖰\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 33,
+                  "raw": "(?<𝖰\\u{1d5a1}𝖥>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 32,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 22,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 19,
+                            "end": 21,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 24,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 24,
+                          "end": 27,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 24,
+                            "end": 26,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 27,
+                          "end": 29,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 32,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 29,
+                            "end": 31,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝖰𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/(?<𝖰𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "(?<𝖰𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "(?<𝖰𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 33,
+                  "raw": "(?<𝖰𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 32,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 22,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 19,
+                            "end": 21,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 24,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 24,
+                          "end": 27,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 24,
+                            "end": 26,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 27,
+                          "end": 29,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 32,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 29,
+                            "end": 31,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 34,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝖰𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/(?<𝖰𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "(?<𝖰𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "(?<𝖰𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 33,
+                  "raw": "(?<𝖰𝖡\\u{1d5a5}>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 18,
+                      "end": 32,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 18,
+                          "end": 19,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 19,
+                          "end": 22,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 19,
+                            "end": 21,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 24,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 24,
+                          "end": 27,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 24,
+                            "end": 26,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 27,
+                          "end": 29,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 29,
+                          "end": 32,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 29,
+                            "end": 31,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝖰𝖡𝖥>q\\w*\\W\\w*\\W\\w*)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/(?<𝖰𝖡𝖥>q\\w*\\W\\w*\\W\\w*)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "(?<𝖰𝖡𝖥>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "(?<𝖰𝖡𝖥>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 26,
+                  "raw": "(?<𝖰𝖡𝖥>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 25,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 15,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 12,
+                            "end": 14,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 17,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 20,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 17,
+                            "end": 19,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 22,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 25,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 22,
+                            "end": 24,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 27,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(?<𝖰𝖡𝖥>q\\w*\\W\\w*\\W\\w*)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/(?<𝖰𝖡𝖥>q\\w*\\W\\w*\\W\\w*)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "(?<𝖰𝖡𝖥>q\\w*\\W\\w*\\W\\w*)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "(?<𝖰𝖡𝖥>q\\w*\\W\\w*\\W\\w*)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 26,
+                  "raw": "(?<𝖰𝖡𝖥>q\\w*\\W\\w*\\W\\w*)",
+                  "name": "𝖰𝖡𝖥",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 25,
+                      "raw": "q\\w*\\W\\w*\\W\\w*",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "q",
+                          "value": 113
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 12,
+                          "end": 15,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 12,
+                            "end": 14,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 15,
+                          "end": 17,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 17,
+                          "end": 20,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 17,
+                            "end": 19,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 20,
+                          "end": 22,
+                          "raw": "\\W",
+                          "kind": "word",
+                          "negate": true
+                        },
+                        {
+                          "type": "Quantifier",
+                          "parent": "♻️../..",
+                          "start": 22,
+                          "end": 25,
+                          "raw": "\\w*",
+                          "min": 0,
+                          "max": "$$Infinity",
+                          "greedy": true,
+                          "element": {
+                            "type": "CharacterSet",
+                            "parent": "♻️..",
+                            "start": 22,
+                            "end": 24,
+                            "raw": "\\w",
+                            "kind": "word",
+                            "negate": false
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\w\\w)(\\w)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/(\\w\\w)(\\w)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(\\w\\w)(\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(\\w\\w)(\\w)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 6,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 11,
+                  "raw": "(\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 10,
+                      "raw": "\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 10,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\w\\w)(\\w)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/(\\w\\w)(\\w)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "(\\w\\w)(\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "(\\w\\w)(\\w)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 7,
+                  "raw": "(\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 6,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 6,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 11,
+                  "raw": "(\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 8,
+                      "end": 10,
+                      "raw": "\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 10,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\w\\w\\w)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/(\\w\\w\\w)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(\\w\\w\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(\\w\\w\\w)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(\\w\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "\\w\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 6,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 10,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(\\w\\w\\w)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/(\\w\\w\\w)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "(\\w\\w\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "(\\w\\w\\w)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 9,
+                  "raw": "(\\w\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 8,
+                      "raw": "\\w\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 4,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 6,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 8,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/(a)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/(a)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "(a)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "(a)",
+              "elements": [
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 4,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 3,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 2,
+                          "end": 3,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?<$>a)./": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/.(?<$>a)./",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": ".(?<$>a).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": ".(?<$>a).",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "(?<$>a)",
+                  "name": "$",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 11,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?<$>a)./u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/.(?<$>a)./u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": ".(?<$>a).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": ".(?<$>a).",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "(?<$>a)",
+                  "name": "$",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?<a>\\w\\w)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/.(?<a>\\w\\w)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": ".(?<a>\\w\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": ".(?<a>\\w\\w)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "(?<a>\\w\\w)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 11,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 9,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 11,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?<a>\\w\\w)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/.(?<a>\\w\\w)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": ".(?<a>\\w\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": ".(?<a>\\w\\w)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "(?<a>\\w\\w)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 11,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 9,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 11,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?<a>a)(.)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/.(?<a>a)(.)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": ".(?<a>a)(.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": ".(?<a>a)(.)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 12,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 11,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?<a>a)(.)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/.(?<a>a)(.)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": ".(?<a>a)(.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": ".(?<a>a)(.)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 12,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 10,
+                      "end": 11,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?<a>a)(?<b>.)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/.(?<a>a)(?<b>.)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": ".(?<a>a)(?<b>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": ".(?<a>a)(?<b>.)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 16,
+                  "raw": "(?<b>.)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 15,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 17,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(?<a>a)(?<b>.)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/.(?<a>a)(?<b>.)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": ".(?<a>a)(?<b>.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": ".(?<a>a)(?<b>.)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "(?<a>a)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 8,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 16,
+                  "raw": "(?<b>.)",
+                  "name": "b",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 14,
+                      "end": 15,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 14,
+                          "end": 15,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(\\w\\w)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/.(\\w\\w)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": ".(\\w\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": ".(\\w\\w)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "(\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 7,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 5,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(\\w\\w)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/.(\\w\\w)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": ".(\\w\\w)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": ".(\\w\\w)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "(\\w\\w)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 7,
+                      "raw": "\\w\\w",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 5,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        },
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 5,
+                          "end": 7,
+                          "raw": "\\w",
+                          "kind": "word",
+                          "negate": false
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(a)(.)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/.(a)(.)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": ".(a)(.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": ".(a)(.)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 8,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(a)(.)/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/.(a)(.)/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": ".(a)(.)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": ".(a)(.)",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 8,
+                  "raw": "(.)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 6,
+                      "end": 7,
+                      "raw": ".",
+                      "elements": [
+                        {
+                          "type": "CharacterSet",
+                          "parent": "♻️../..",
+                          "start": 6,
+                          "end": 7,
+                          "raw": ".",
+                          "kind": "any"
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(a)./": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/.(a)./",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": ".(a).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": ".(a).",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/.(a)./u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 8,
+        "raw": "/.(a)./u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": ".(a).",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": ".(a).",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 5,
+                  "raw": "(a)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 3,
+                      "end": 4,
+                      "raw": "a",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 3,
+                          "end": 4,
+                          "raw": "a",
+                          "value": 97
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 8,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\1(b)\\k<a>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/\\1(b)\\k<a>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "\\1(b)\\k<a>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "\\1(b)\\k<a>",
+              "elements": [
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\1",
+                  "ref": 1,
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 6,
+                  "raw": "(b)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 4,
+                      "end": 5,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 4,
+                          "end": 5,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../0"
+                  ]
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 8,
+                  "raw": "\\k",
+                  "value": 107
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "<",
+                  "value": 60
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": ">",
+                  "value": 62
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 12,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\k(?<a>.)/": {
+      "error": {
+        "message": "Invalid regular expression: /\\k(?<a>.)/: Invalid named reference",
+        "index": 3
+      }
+    },
+    "/\\k<4>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/\\k<4>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 6,
+          "raw": "\\k<4>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 6,
+              "raw": "\\k<4>",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\k",
+                  "value": 107
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "<",
+                  "value": 60
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "4",
+                  "value": 52
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ">",
+                  "value": 62
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 7,
+          "end": 7,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\k<>/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\k<>/u: Invalid capture group name",
+        "index": 4
+      }
+    },
+    "/\\k<a(?<a>.)/": {
+      "error": {
+        "message": "Invalid regular expression: /\\k<a(?<a>.)/: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/\\k<a(?<a>a)/": {
+      "error": {
+        "message": "Invalid regular expression: /\\k<a(?<a>a)/: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/\\k<a/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/\\k<a/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 5,
+          "raw": "\\k<a",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 5,
+              "raw": "\\k<a",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\k",
+                  "value": 107
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "<",
+                  "value": 60
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "a",
+                  "value": 97
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 6,
+          "end": 6,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\k<a/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\k<a/u: Invalid capture group name",
+        "index": 5
+      }
+    },
+    "/\\k<a>(<a>x)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/\\k<a>(<a>x)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "\\k<a>(<a>x)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "\\k<a>(<a>x)",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\k",
+                  "value": 107
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "<",
+                  "value": 60
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ">",
+                  "value": 62
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 12,
+                  "raw": "(<a>x)",
+                  "name": null,
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 7,
+                      "end": 11,
+                      "raw": "<a>x",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 7,
+                          "end": 8,
+                          "raw": "<",
+                          "value": 60
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 8,
+                          "end": 9,
+                          "raw": "a",
+                          "value": 97
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 9,
+                          "end": 10,
+                          "raw": ">",
+                          "value": 62
+                        },
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 10,
+                          "end": 11,
+                          "raw": "x",
+                          "value": 120
+                        }
+                      ]
+                    }
+                  ],
+                  "references": []
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 13,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\k<a>(?<a>b)\\w\\k<a>/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/\\k<a>(?<a>b)\\w\\k<a>/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "\\k<a>(?<a>b)\\w\\k<a>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "\\k<a>(?<a>b)\\w\\k<a>",
+              "elements": [
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 13,
+                  "raw": "(?<a>b)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 12,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../0",
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 15,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 20,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 21,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\k<a>(?<a>b)\\w\\k<a>/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/\\k<a>(?<a>b)\\w\\k<a>/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "\\k<a>(?<a>b)\\w\\k<a>",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "\\k<a>(?<a>b)\\w\\k<a>",
+              "elements": [
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 13,
+                  "raw": "(?<a>b)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 12,
+                      "raw": "b",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "b",
+                          "value": 98
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../0",
+                    "♻️../3"
+                  ]
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 15,
+                  "raw": "\\w",
+                  "kind": "word",
+                  "negate": false
+                },
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 20,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\k<a>(?<a>x)/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/\\k<a>(?<a>x)/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "\\k<a>(?<a>x)",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "\\k<a>(?<a>x)",
+              "elements": [
+                {
+                  "type": "Backreference",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 6,
+                  "raw": "\\k<a>",
+                  "ref": "a",
+                  "ambiguous": false,
+                  "resolved": "♻️../1"
+                },
+                {
+                  "type": "CapturingGroup",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 13,
+                  "raw": "(?<a>x)",
+                  "name": "a",
+                  "alternatives": [
+                    {
+                      "type": "Alternative",
+                      "parent": "♻️../..",
+                      "start": 11,
+                      "end": 12,
+                      "raw": "x",
+                      "elements": [
+                        {
+                          "type": "Character",
+                          "parent": "♻️../..",
+                          "start": 11,
+                          "end": 12,
+                          "raw": "x",
+                          "value": 120
+                        }
+                      ]
+                    }
+                  ],
+                  "references": [
+                    "♻️../0"
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 14,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\k<a>(?<ab>a)/": {
+      "error": {
+        "message": "Invalid regular expression: /\\k<a>(?<ab>a)/: Invalid named capture referenced",
+        "index": 14
+      }
+    },
+    "/\\k<a>(?<ab>a)/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\k<a>(?<ab>a)/u: Invalid named capture referenced",
+        "index": 14
+      }
+    },
+    "/\\k<a>(?<b>x)/": {
+      "error": {
+        "message": "Invalid regular expression: /\\k<a>(?<b>x)/: Invalid named capture referenced",
+        "index": 13
+      }
+    },
+    "/\\k<a>\\1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 9,
+        "raw": "/\\k<a>\\1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "\\k<a>\\1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "\\k<a>\\1",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 3,
+                  "raw": "\\k",
+                  "value": 107
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "<",
+                  "value": 60
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 4,
+                  "end": 5,
+                  "raw": "a",
+                  "value": 97
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 5,
+                  "end": 6,
+                  "raw": ">",
+                  "value": 62
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 6,
+                  "end": 8,
+                  "raw": "\\1",
+                  "value": 1
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 9,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/regexp-unicode-property-escapes-and-regexp-v-flag.json b/test/fixtures/parser/literal/test262/regexp-unicode-property-escapes-and-regexp-v-flag.json
new file mode 100644
index 0000000..2f3b353
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/regexp-unicode-property-escapes-and-regexp-v-flag.json
@@ -0,0 +1,8273 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/property-escapes/generated/strings/Basic_Emoji-negative-CharacterClass.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/Basic_Emoji-negative-P.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/Basic_Emoji-negative-u.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/Basic_Emoji.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/Emoji_Keycap_Sequence-negative-CharacterClass.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/Emoji_Keycap_Sequence-negative-P.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/Emoji_Keycap_Sequence-negative-u.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/Emoji_Keycap_Sequence.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji-negative-CharacterClass.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji-negative-P.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji-negative-u.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Flag_Sequence-negative-CharacterClass.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Flag_Sequence-negative-P.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Flag_Sequence-negative-u.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Flag_Sequence.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Modifier_Sequence-negative-CharacterClass.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Modifier_Sequence-negative-P.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Modifier_Sequence-negative-u.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Modifier_Sequence.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Tag_Sequence-negative-CharacterClass.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Tag_Sequence-negative-P.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Tag_Sequence-negative-u.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Tag_Sequence.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_ZWJ_Sequence-negative-CharacterClass.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_ZWJ_Sequence-negative-P.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_ZWJ_Sequence-negative-u.js",
+    "test/built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_ZWJ_Sequence.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-difference-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-difference-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-difference-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-difference-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-intersection-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-intersection-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-union-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-union-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-intersection-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-intersection-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-union-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-union-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-difference-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-difference-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-intersection-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-intersection-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-difference-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-difference-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-difference-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-difference-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-difference-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-difference-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-intersection-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-intersection-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-intersection-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-intersection-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-intersection-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-intersection-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-union-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-union-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-union-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-union-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-union-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-property-escape-union-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-union-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-union-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-difference-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-difference-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-difference-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-difference-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-difference-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-difference-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-intersection-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-intersection-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-intersection-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-intersection-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-intersection-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-intersection-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-union-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-union-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-union-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-union-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-union-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/property-of-strings-escape-union-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-difference-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-difference-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-intersection-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-intersection-property-of-strings-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-union-character-property-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-union-property-of-strings-escape.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/[^\\p{Basic_Emoji}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^\\p{Basic_Emoji}]/v: Negated character class may contain strings",
+        "index": 19
+      }
+    },
+    "/[^\\p{Emoji_Keycap_Sequence}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^\\p{Emoji_Keycap_Sequence}]/v: Negated character class may contain strings",
+        "index": 29
+      }
+    },
+    "/[^\\p{RGI_Emoji_Flag_Sequence}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^\\p{RGI_Emoji_Flag_Sequence}]/v: Negated character class may contain strings",
+        "index": 31
+      }
+    },
+    "/[^\\p{RGI_Emoji_Modifier_Sequence}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^\\p{RGI_Emoji_Modifier_Sequence}]/v: Negated character class may contain strings",
+        "index": 35
+      }
+    },
+    "/[^\\p{RGI_Emoji_Tag_Sequence}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^\\p{RGI_Emoji_Tag_Sequence}]/v: Negated character class may contain strings",
+        "index": 30
+      }
+    },
+    "/[^\\p{RGI_Emoji_ZWJ_Sequence}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^\\p{RGI_Emoji_ZWJ_Sequence}]/v: Negated character class may contain strings",
+        "index": 30
+      }
+    },
+    "/[^\\p{RGI_Emoji}]/v": {
+      "error": {
+        "message": "Invalid regular expression: /[^\\p{RGI_Emoji}]/v: Negated character class may contain strings",
+        "index": 17
+      }
+    },
+    "/\\P{Basic_Emoji}/v": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Basic_Emoji}/v: Invalid property name",
+        "index": 16
+      }
+    },
+    "/\\P{Emoji_Keycap_Sequence}/v": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Emoji_Keycap_Sequence}/v: Invalid property name",
+        "index": 26
+      }
+    },
+    "/\\P{RGI_Emoji_Flag_Sequence}/v": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{RGI_Emoji_Flag_Sequence}/v: Invalid property name",
+        "index": 28
+      }
+    },
+    "/\\P{RGI_Emoji_Modifier_Sequence}/v": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{RGI_Emoji_Modifier_Sequence}/v: Invalid property name",
+        "index": 32
+      }
+    },
+    "/\\P{RGI_Emoji_Tag_Sequence}/v": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{RGI_Emoji_Tag_Sequence}/v: Invalid property name",
+        "index": 27
+      }
+    },
+    "/\\P{RGI_Emoji_ZWJ_Sequence}/v": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{RGI_Emoji_ZWJ_Sequence}/v: Invalid property name",
+        "index": 27
+      }
+    },
+    "/\\P{RGI_Emoji}/v": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{RGI_Emoji}/v: Invalid property name",
+        "index": 14
+      }
+    },
+    "/\\p{Basic_Emoji}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Basic_Emoji}/u: Invalid property name",
+        "index": 15
+      }
+    },
+    "/\\p{Emoji_Keycap_Sequence}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Emoji_Keycap_Sequence}/u: Invalid property name",
+        "index": 25
+      }
+    },
+    "/\\p{RGI_Emoji_Flag_Sequence}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{RGI_Emoji_Flag_Sequence}/u: Invalid property name",
+        "index": 27
+      }
+    },
+    "/\\p{RGI_Emoji_Modifier_Sequence}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{RGI_Emoji_Modifier_Sequence}/u: Invalid property name",
+        "index": 31
+      }
+    },
+    "/\\p{RGI_Emoji_Tag_Sequence}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{RGI_Emoji_Tag_Sequence}/u: Invalid property name",
+        "index": 26
+      }
+    },
+    "/\\p{RGI_Emoji_ZWJ_Sequence}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{RGI_Emoji_ZWJ_Sequence}/u: Invalid property name",
+        "index": 26
+      }
+    },
+    "/\\p{RGI_Emoji}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{RGI_Emoji}/u: Invalid property name",
+        "index": 13
+      }
+    },
+    "/^[[0-9]&&\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^[[0-9]&&\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^[[0-9]&&\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^[[0-9]&&\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "[[0-9]&&\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "[[0-9]&&\\p{ASCII_Hex_Digit}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 29,
+                      "raw": "[0-9]&&\\p{ASCII_Hex_Digit}",
+                      "left": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 29,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]&&\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^[[0-9]&&\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^[[0-9]&&\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^[[0-9]&&\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "[[0-9]&&\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "[[0-9]&&\\p{Emoji_Keycap_Sequence}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 35,
+                      "raw": "[0-9]&&\\p{Emoji_Keycap_Sequence}",
+                      "left": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 35,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]--\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^[[0-9]--\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^[[0-9]--\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^[[0-9]--\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "[[0-9]--\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "[[0-9]--\\p{ASCII_Hex_Digit}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 29,
+                      "raw": "[0-9]--\\p{ASCII_Hex_Digit}",
+                      "left": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 29,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]--\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^[[0-9]--\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^[[0-9]--\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^[[0-9]--\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "[[0-9]--\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "[[0-9]--\\p{Emoji_Keycap_Sequence}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 35,
+                      "raw": "[0-9]--\\p{Emoji_Keycap_Sequence}",
+                      "left": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 35,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^[[0-9]\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^[[0-9]\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^[[0-9]\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "[[0-9]\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "[[0-9]\\p{ASCII_Hex_Digit}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClass",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 8,
+                        "end": 27,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^[[0-9]\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^[[0-9]\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^[[0-9]\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "[[0-9]\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "[[0-9]\\p{Emoji_Keycap_Sequence}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClass",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 8,
+                        "end": 33,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d&&\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^[\\d&&\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^[\\d&&\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^[\\d&&\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "[\\d&&\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "[\\d&&\\p{ASCII_Hex_Digit}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 26,
+                      "raw": "\\d&&\\p{ASCII_Hex_Digit}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 26,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d&&\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^[\\d&&\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^[\\d&&\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^[\\d&&\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "[\\d&&\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "[\\d&&\\p{Emoji_Keycap_Sequence}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 32,
+                      "raw": "\\d&&\\p{Emoji_Keycap_Sequence}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 32,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d--\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^[\\d--\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^[\\d--\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^[\\d--\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "[\\d--\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "[\\d--\\p{ASCII_Hex_Digit}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 26,
+                      "raw": "\\d--\\p{ASCII_Hex_Digit}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 26,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d--\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^[\\d--\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^[\\d--\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^[\\d--\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "[\\d--\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "[\\d--\\p{Emoji_Keycap_Sequence}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 32,
+                      "raw": "\\d--\\p{Emoji_Keycap_Sequence}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 32,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^[\\d\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^[\\d\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^[\\d\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "[\\d\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "[\\d\\p{ASCII_Hex_Digit}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 24,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^[\\d\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^[\\d\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^[\\d\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "[\\d\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "[\\d\\p{Emoji_Keycap_Sequence}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 30,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}&&[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^[\\p{ASCII_Hex_Digit}&&[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^[\\p{ASCII_Hex_Digit}&&[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^[\\p{ASCII_Hex_Digit}&&[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "[\\p{ASCII_Hex_Digit}&&[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "[\\p{ASCII_Hex_Digit}&&[0-9]]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 29,
+                      "raw": "\\p{ASCII_Hex_Digit}&&[0-9]",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 24,
+                        "end": 29,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 25,
+                            "end": 28,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 25,
+                              "end": 26,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 27,
+                              "end": 28,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}&&\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^[\\p{ASCII_Hex_Digit}&&\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^[\\p{ASCII_Hex_Digit}&&\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^[\\p{ASCII_Hex_Digit}&&\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "[\\p{ASCII_Hex_Digit}&&\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "[\\p{ASCII_Hex_Digit}&&\\d]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 26,
+                      "raw": "\\p{ASCII_Hex_Digit}&&\\d",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 24,
+                        "end": 26,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}&&\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 48,
+        "raw": "/^[\\p{ASCII_Hex_Digit}&&\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 46,
+          "raw": "^[\\p{ASCII_Hex_Digit}&&\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 46,
+              "raw": "^[\\p{ASCII_Hex_Digit}&&\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 45,
+                  "raw": "[\\p{ASCII_Hex_Digit}&&\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 44,
+                    "raw": "[\\p{ASCII_Hex_Digit}&&\\p{ASCII_Hex_Digit}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 43,
+                      "raw": "\\p{ASCII_Hex_Digit}&&\\p{ASCII_Hex_Digit}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 24,
+                        "end": 43,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 45,
+                  "end": 46,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 47,
+          "end": 48,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}&&\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 54,
+        "raw": "/^[\\p{ASCII_Hex_Digit}&&\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 52,
+          "raw": "^[\\p{ASCII_Hex_Digit}&&\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 52,
+              "raw": "^[\\p{ASCII_Hex_Digit}&&\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 51,
+                  "raw": "[\\p{ASCII_Hex_Digit}&&\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 50,
+                    "raw": "[\\p{ASCII_Hex_Digit}&&\\p{Emoji_Keycap_Sequence}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 49,
+                      "raw": "\\p{ASCII_Hex_Digit}&&\\p{Emoji_Keycap_Sequence}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 24,
+                        "end": 49,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 51,
+                  "end": 52,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 53,
+          "end": 54,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 52,
+        "raw": "/^[\\p{ASCII_Hex_Digit}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 50,
+          "raw": "^[\\p{ASCII_Hex_Digit}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 50,
+              "raw": "^[\\p{ASCII_Hex_Digit}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 49,
+                  "raw": "[\\p{ASCII_Hex_Digit}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 48,
+                    "raw": "[\\p{ASCII_Hex_Digit}&&\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 47,
+                      "raw": "\\p{ASCII_Hex_Digit}&&\\q{0|2|4|9\\uFE0F\\u20E3}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 24,
+                        "end": 47,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 27,
+                            "end": 28,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 27,
+                                "end": 28,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 29,
+                            "end": 30,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 29,
+                                "end": 30,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 31,
+                            "end": 32,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 31,
+                                "end": 32,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 33,
+                            "end": 46,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 33,
+                                "end": 34,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 34,
+                                "end": 40,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 40,
+                                "end": 46,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 49,
+                  "end": 50,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 51,
+          "end": 52,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}&&_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^[\\p{ASCII_Hex_Digit}&&_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^[\\p{ASCII_Hex_Digit}&&_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^[\\p{ASCII_Hex_Digit}&&_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "[\\p{ASCII_Hex_Digit}&&_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "[\\p{ASCII_Hex_Digit}&&_]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 25,
+                      "raw": "\\p{ASCII_Hex_Digit}&&_",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 24,
+                        "end": 25,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}--[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^[\\p{ASCII_Hex_Digit}--[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^[\\p{ASCII_Hex_Digit}--[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^[\\p{ASCII_Hex_Digit}--[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "[\\p{ASCII_Hex_Digit}--[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "[\\p{ASCII_Hex_Digit}--[0-9]]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 29,
+                      "raw": "\\p{ASCII_Hex_Digit}--[0-9]",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 24,
+                        "end": 29,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 25,
+                            "end": 28,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 25,
+                              "end": 26,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 27,
+                              "end": 28,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}--\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^[\\p{ASCII_Hex_Digit}--\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^[\\p{ASCII_Hex_Digit}--\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^[\\p{ASCII_Hex_Digit}--\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "[\\p{ASCII_Hex_Digit}--\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "[\\p{ASCII_Hex_Digit}--\\d]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 26,
+                      "raw": "\\p{ASCII_Hex_Digit}--\\d",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 24,
+                        "end": 26,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}--\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 48,
+        "raw": "/^[\\p{ASCII_Hex_Digit}--\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 46,
+          "raw": "^[\\p{ASCII_Hex_Digit}--\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 46,
+              "raw": "^[\\p{ASCII_Hex_Digit}--\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 45,
+                  "raw": "[\\p{ASCII_Hex_Digit}--\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 44,
+                    "raw": "[\\p{ASCII_Hex_Digit}--\\p{ASCII_Hex_Digit}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 43,
+                      "raw": "\\p{ASCII_Hex_Digit}--\\p{ASCII_Hex_Digit}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 24,
+                        "end": 43,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 45,
+                  "end": 46,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 47,
+          "end": 48,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}--\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 54,
+        "raw": "/^[\\p{ASCII_Hex_Digit}--\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 52,
+          "raw": "^[\\p{ASCII_Hex_Digit}--\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 52,
+              "raw": "^[\\p{ASCII_Hex_Digit}--\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 51,
+                  "raw": "[\\p{ASCII_Hex_Digit}--\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 50,
+                    "raw": "[\\p{ASCII_Hex_Digit}--\\p{Emoji_Keycap_Sequence}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 49,
+                      "raw": "\\p{ASCII_Hex_Digit}--\\p{Emoji_Keycap_Sequence}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 24,
+                        "end": 49,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 51,
+                  "end": 52,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 53,
+          "end": 54,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}--\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 52,
+        "raw": "/^[\\p{ASCII_Hex_Digit}--\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 50,
+          "raw": "^[\\p{ASCII_Hex_Digit}--\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 50,
+              "raw": "^[\\p{ASCII_Hex_Digit}--\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 49,
+                  "raw": "[\\p{ASCII_Hex_Digit}--\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 48,
+                    "raw": "[\\p{ASCII_Hex_Digit}--\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 47,
+                      "raw": "\\p{ASCII_Hex_Digit}--\\q{0|2|4|9\\uFE0F\\u20E3}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 24,
+                        "end": 47,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 27,
+                            "end": 28,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 27,
+                                "end": 28,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 29,
+                            "end": 30,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 29,
+                                "end": 30,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 31,
+                            "end": 32,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 31,
+                                "end": 32,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 33,
+                            "end": 46,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 33,
+                                "end": 34,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 34,
+                                "end": 40,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 40,
+                                "end": 46,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 49,
+                  "end": 50,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 51,
+          "end": 52,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}--_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^[\\p{ASCII_Hex_Digit}--_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^[\\p{ASCII_Hex_Digit}--_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^[\\p{ASCII_Hex_Digit}--_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "[\\p{ASCII_Hex_Digit}--_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "[\\p{ASCII_Hex_Digit}--_]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 25,
+                      "raw": "\\p{ASCII_Hex_Digit}--_",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 24,
+                        "end": 25,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^[\\p{ASCII_Hex_Digit}[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^[\\p{ASCII_Hex_Digit}[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^[\\p{ASCII_Hex_Digit}[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "[\\p{ASCII_Hex_Digit}[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "[\\p{ASCII_Hex_Digit}[0-9]]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      {
+                        "type": "CharacterClass",
+                        "parent": "♻️../..",
+                        "start": 22,
+                        "end": 27,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 23,
+                            "end": 26,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 23,
+                              "end": 24,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 25,
+                              "end": 26,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^[\\p{ASCII_Hex_Digit}\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^[\\p{ASCII_Hex_Digit}\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^[\\p{ASCII_Hex_Digit}\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "[\\p{ASCII_Hex_Digit}\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "[\\p{ASCII_Hex_Digit}\\d]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 22,
+                        "end": 24,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 46,
+        "raw": "/^[\\p{ASCII_Hex_Digit}\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 44,
+          "raw": "^[\\p{ASCII_Hex_Digit}\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 44,
+              "raw": "^[\\p{ASCII_Hex_Digit}\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 43,
+                  "raw": "[\\p{ASCII_Hex_Digit}\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 42,
+                    "raw": "[\\p{ASCII_Hex_Digit}\\p{ASCII_Hex_Digit}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 22,
+                        "end": 41,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 43,
+                  "end": 44,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 45,
+          "end": 46,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 52,
+        "raw": "/^[\\p{ASCII_Hex_Digit}\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 50,
+          "raw": "^[\\p{ASCII_Hex_Digit}\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 50,
+              "raw": "^[\\p{ASCII_Hex_Digit}\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 49,
+                  "raw": "[\\p{ASCII_Hex_Digit}\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 48,
+                    "raw": "[\\p{ASCII_Hex_Digit}\\p{Emoji_Keycap_Sequence}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 22,
+                        "end": 47,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 49,
+                  "end": 50,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 51,
+          "end": 52,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 50,
+        "raw": "/^[\\p{ASCII_Hex_Digit}\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 48,
+          "raw": "^[\\p{ASCII_Hex_Digit}\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 48,
+              "raw": "^[\\p{ASCII_Hex_Digit}\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 47,
+                  "raw": "[\\p{ASCII_Hex_Digit}\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 46,
+                    "raw": "[\\p{ASCII_Hex_Digit}\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️../..",
+                        "start": 22,
+                        "end": 45,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 25,
+                            "end": 26,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 25,
+                                "end": 26,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 27,
+                            "end": 28,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 27,
+                                "end": 28,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 29,
+                            "end": 30,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 29,
+                                "end": 30,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 31,
+                            "end": 44,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 31,
+                                "end": 32,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 32,
+                                "end": 38,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 38,
+                                "end": 44,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 47,
+                  "end": 48,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 49,
+          "end": 50,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{ASCII_Hex_Digit}_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^[\\p{ASCII_Hex_Digit}_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^[\\p{ASCII_Hex_Digit}_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^[\\p{ASCII_Hex_Digit}_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "[\\p{ASCII_Hex_Digit}_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "[\\p{ASCII_Hex_Digit}_]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 22,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 22,
+                        "end": 23,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}&&[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}&&[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}&&[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}&&[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}&&[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}&&[0-9]]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 35,
+                      "raw": "\\p{Emoji_Keycap_Sequence}&&[0-9]",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 30,
+                        "end": 35,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 31,
+                            "end": 34,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 31,
+                              "end": 32,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 33,
+                              "end": 34,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}&&\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}&&\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}&&\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}&&\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}&&\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}&&\\d]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 32,
+                      "raw": "\\p{Emoji_Keycap_Sequence}&&\\d",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 30,
+                        "end": 32,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}&&\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 54,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}&&\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 52,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}&&\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 52,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}&&\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 51,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}&&\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 50,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}&&\\p{ASCII_Hex_Digit}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 49,
+                      "raw": "\\p{Emoji_Keycap_Sequence}&&\\p{ASCII_Hex_Digit}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 30,
+                        "end": 49,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 51,
+                  "end": 52,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 53,
+          "end": 54,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}&&\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 60,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}&&\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 58,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}&&\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 58,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}&&\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 57,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}&&\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 56,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}&&\\p{Emoji_Keycap_Sequence}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 55,
+                      "raw": "\\p{Emoji_Keycap_Sequence}&&\\p{Emoji_Keycap_Sequence}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 30,
+                        "end": 55,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 57,
+                  "end": 58,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 59,
+          "end": 60,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 58,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 56,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 56,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 55,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 54,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}&&\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 53,
+                      "raw": "\\p{Emoji_Keycap_Sequence}&&\\q{0|2|4|9\\uFE0F\\u20E3}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 30,
+                        "end": 53,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 33,
+                            "end": 34,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 33,
+                                "end": 34,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 35,
+                            "end": 36,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 35,
+                                "end": 36,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 37,
+                            "end": 38,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 37,
+                                "end": 38,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 39,
+                            "end": 52,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 39,
+                                "end": 40,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 40,
+                                "end": 46,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 46,
+                                "end": 52,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 55,
+                  "end": 56,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 57,
+          "end": 58,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}&&_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}&&_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}&&_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}&&_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}&&_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}&&_]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 31,
+                      "raw": "\\p{Emoji_Keycap_Sequence}&&_",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 30,
+                        "end": 31,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}--[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}--[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}--[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}--[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}--[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}--[0-9]]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 35,
+                      "raw": "\\p{Emoji_Keycap_Sequence}--[0-9]",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 30,
+                        "end": 35,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 31,
+                            "end": 34,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 31,
+                              "end": 32,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 33,
+                              "end": 34,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}--\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}--\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}--\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}--\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}--\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}--\\d]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 32,
+                      "raw": "\\p{Emoji_Keycap_Sequence}--\\d",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 30,
+                        "end": 32,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}--\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 54,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}--\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 52,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}--\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 52,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}--\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 51,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}--\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 50,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}--\\p{ASCII_Hex_Digit}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 49,
+                      "raw": "\\p{Emoji_Keycap_Sequence}--\\p{ASCII_Hex_Digit}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 30,
+                        "end": 49,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 51,
+                  "end": 52,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 53,
+          "end": 54,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}--\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 60,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}--\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 58,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}--\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 58,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}--\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 57,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}--\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 56,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}--\\p{Emoji_Keycap_Sequence}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 55,
+                      "raw": "\\p{Emoji_Keycap_Sequence}--\\p{Emoji_Keycap_Sequence}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 30,
+                        "end": 55,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 57,
+                  "end": 58,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 59,
+          "end": 60,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}--\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 58,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}--\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 56,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}--\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 56,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}--\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 55,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}--\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 54,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}--\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 53,
+                      "raw": "\\p{Emoji_Keycap_Sequence}--\\q{0|2|4|9\\uFE0F\\u20E3}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 30,
+                        "end": 53,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 33,
+                            "end": 34,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 33,
+                                "end": 34,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 35,
+                            "end": 36,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 35,
+                                "end": 36,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 37,
+                            "end": 38,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 37,
+                                "end": 38,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 39,
+                            "end": 52,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 39,
+                                "end": 40,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 40,
+                                "end": 46,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 46,
+                                "end": 52,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 55,
+                  "end": 56,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 57,
+          "end": 58,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}--_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}--_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}--_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}--_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}--_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}--_]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 31,
+                      "raw": "\\p{Emoji_Keycap_Sequence}--_",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 30,
+                        "end": 31,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}[0-9]]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      {
+                        "type": "CharacterClass",
+                        "parent": "♻️../..",
+                        "start": 28,
+                        "end": 33,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 29,
+                            "end": 32,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 29,
+                              "end": 30,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 31,
+                              "end": 32,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}\\d]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 28,
+                        "end": 30,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 52,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 50,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 50,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 49,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 48,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}\\p{ASCII_Hex_Digit}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 28,
+                        "end": 47,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 49,
+                  "end": 50,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 51,
+          "end": 52,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 58,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 56,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 56,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 55,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 54,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}\\p{Emoji_Keycap_Sequence}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 28,
+                        "end": 53,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 55,
+                  "end": 56,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 57,
+          "end": 58,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 56,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 54,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 54,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 53,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 52,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️../..",
+                        "start": 28,
+                        "end": 51,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 31,
+                            "end": 32,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 31,
+                                "end": 32,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 33,
+                            "end": 34,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 33,
+                                "end": 34,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 35,
+                            "end": 36,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 35,
+                                "end": 36,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 37,
+                            "end": 50,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 37,
+                                "end": 38,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 38,
+                                "end": 44,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 44,
+                                "end": 50,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 53,
+                  "end": 54,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 55,
+          "end": 56,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\p{Emoji_Keycap_Sequence}_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^[\\p{Emoji_Keycap_Sequence}_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^[\\p{Emoji_Keycap_Sequence}_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^[\\p{Emoji_Keycap_Sequence}_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "[\\p{Emoji_Keycap_Sequence}_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "[\\p{Emoji_Keycap_Sequence}_]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 28,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 28,
+                        "end": 29,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 52,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 50,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 50,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 49,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 48,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{ASCII_Hex_Digit}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 47,
+                      "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{ASCII_Hex_Digit}",
+                      "left": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 28,
+                        "end": 47,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 49,
+                  "end": 50,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 51,
+          "end": 52,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 58,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 56,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 56,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 55,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 54,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{Emoji_Keycap_Sequence}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 53,
+                      "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}&&\\p{Emoji_Keycap_Sequence}",
+                      "left": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 28,
+                        "end": 53,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 55,
+                  "end": 56,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 57,
+          "end": 58,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 52,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 50,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 50,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 49,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 48,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{ASCII_Hex_Digit}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 47,
+                      "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{ASCII_Hex_Digit}",
+                      "left": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 28,
+                        "end": 47,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 49,
+                  "end": 50,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 51,
+          "end": 52,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 58,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 56,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 56,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 55,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 54,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{Emoji_Keycap_Sequence}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 53,
+                      "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}--\\p{Emoji_Keycap_Sequence}",
+                      "left": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 28,
+                        "end": 53,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 55,
+                  "end": 56,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 57,
+          "end": 58,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 50,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 48,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 48,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 47,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 46,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}\\p{ASCII_Hex_Digit}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 26,
+                        "end": 45,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 47,
+                  "end": 48,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 49,
+          "end": 50,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 56,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 54,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 54,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 53,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 52,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}\\p{Emoji_Keycap_Sequence}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 26,
+                        "end": 51,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 53,
+                  "end": 54,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 55,
+          "end": 56,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_&&\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^[_&&\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^[_&&\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^[_&&\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "[_&&\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "[_&&\\p{ASCII_Hex_Digit}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 25,
+                      "raw": "_&&\\p{ASCII_Hex_Digit}",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 25,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_&&\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^[_&&\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^[_&&\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^[_&&\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "[_&&\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "[_&&\\p{Emoji_Keycap_Sequence}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 31,
+                      "raw": "_&&\\p{Emoji_Keycap_Sequence}",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 31,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_--\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^[_--\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^[_--\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^[_--\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "[_--\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "[_--\\p{ASCII_Hex_Digit}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 25,
+                      "raw": "_--\\p{ASCII_Hex_Digit}",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 25,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_--\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^[_--\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^[_--\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^[_--\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "[_--\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "[_--\\p{Emoji_Keycap_Sequence}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 31,
+                      "raw": "_--\\p{Emoji_Keycap_Sequence}",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 31,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_\\p{ASCII_Hex_Digit}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^[_\\p{ASCII_Hex_Digit}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^[_\\p{ASCII_Hex_Digit}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^[_\\p{ASCII_Hex_Digit}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "[_\\p{ASCII_Hex_Digit}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "[_\\p{ASCII_Hex_Digit}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 23,
+                        "raw": "\\p{ASCII_Hex_Digit}",
+                        "kind": "property",
+                        "strings": false,
+                        "key": "ASCII_Hex_Digit",
+                        "value": null,
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_\\p{Emoji_Keycap_Sequence}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^[_\\p{Emoji_Keycap_Sequence}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^[_\\p{Emoji_Keycap_Sequence}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^[_\\p{Emoji_Keycap_Sequence}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "[_\\p{Emoji_Keycap_Sequence}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "[_\\p{Emoji_Keycap_Sequence}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 29,
+                        "raw": "\\p{Emoji_Keycap_Sequence}",
+                        "kind": "property",
+                        "strings": true,
+                        "key": "Emoji_Keycap_Sequence",
+                        "value": null,
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^\\p{Basic_Emoji}+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Basic_Emoji}+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Basic_Emoji}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Basic_Emoji}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Basic_Emoji}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Basic_Emoji}",
+                    "kind": "property",
+                    "strings": true,
+                    "key": "Basic_Emoji",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^\\p{Emoji_Keycap_Sequence}+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\p{Emoji_Keycap_Sequence}+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\p{Emoji_Keycap_Sequence}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\p{Emoji_Keycap_Sequence}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\p{Emoji_Keycap_Sequence}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\p{Emoji_Keycap_Sequence}",
+                    "kind": "property",
+                    "strings": true,
+                    "key": "Emoji_Keycap_Sequence",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^\\p{RGI_Emoji_Flag_Sequence}+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{RGI_Emoji_Flag_Sequence}+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{RGI_Emoji_Flag_Sequence}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{RGI_Emoji_Flag_Sequence}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{RGI_Emoji_Flag_Sequence}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{RGI_Emoji_Flag_Sequence}",
+                    "kind": "property",
+                    "strings": true,
+                    "key": "RGI_Emoji_Flag_Sequence",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^\\p{RGI_Emoji_Modifier_Sequence}+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{RGI_Emoji_Modifier_Sequence}+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{RGI_Emoji_Modifier_Sequence}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{RGI_Emoji_Modifier_Sequence}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{RGI_Emoji_Modifier_Sequence}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{RGI_Emoji_Modifier_Sequence}",
+                    "kind": "property",
+                    "strings": true,
+                    "key": "RGI_Emoji_Modifier_Sequence",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^\\p{RGI_Emoji_Tag_Sequence}+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{RGI_Emoji_Tag_Sequence}+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{RGI_Emoji_Tag_Sequence}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{RGI_Emoji_Tag_Sequence}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{RGI_Emoji_Tag_Sequence}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{RGI_Emoji_Tag_Sequence}",
+                    "kind": "property",
+                    "strings": true,
+                    "key": "RGI_Emoji_Tag_Sequence",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^\\p{RGI_Emoji_ZWJ_Sequence}+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{RGI_Emoji_ZWJ_Sequence}+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{RGI_Emoji_ZWJ_Sequence}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{RGI_Emoji_ZWJ_Sequence}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{RGI_Emoji_ZWJ_Sequence}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{RGI_Emoji_ZWJ_Sequence}",
+                    "kind": "property",
+                    "strings": true,
+                    "key": "RGI_Emoji_ZWJ_Sequence",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^\\p{RGI_Emoji}+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{RGI_Emoji}+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{RGI_Emoji}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{RGI_Emoji}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{RGI_Emoji}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{RGI_Emoji}",
+                    "kind": "property",
+                    "strings": true,
+                    "key": "RGI_Emoji",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/regexp-unicode-property-escapes.json b/test/fixtures/parser/literal/test262/regexp-unicode-property-escapes.json
new file mode 100644
index 0000000..bc5e95a
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/regexp-unicode-property-escapes.json
@@ -0,0 +1,260338 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_F-negated.js",
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_F.js",
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_Invalid-negated.js",
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_Invalid.js",
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_N-negated.js",
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_N.js",
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_No-negated.js",
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_No.js",
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_T-negated.js",
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_T.js",
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_Y-negated.js",
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_Y.js",
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_Yes-negated.js",
+    "test/built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_Yes.js",
+    "test/built-ins/RegExp/property-escapes/character-class-range-end.js",
+    "test/built-ins/RegExp/property-escapes/character-class-range-no-dash-end.js",
+    "test/built-ins/RegExp/property-escapes/character-class-range-no-dash-start.js",
+    "test/built-ins/RegExp/property-escapes/character-class-range-start.js",
+    "test/built-ins/RegExp/property-escapes/character-class.js",
+    "test/built-ins/RegExp/property-escapes/generated/ASCII.js",
+    "test/built-ins/RegExp/property-escapes/generated/ASCII_Hex_Digit.js",
+    "test/built-ins/RegExp/property-escapes/generated/Alphabetic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Any.js",
+    "test/built-ins/RegExp/property-escapes/generated/Assigned.js",
+    "test/built-ins/RegExp/property-escapes/generated/Bidi_Control.js",
+    "test/built-ins/RegExp/property-escapes/generated/Bidi_Mirrored.js",
+    "test/built-ins/RegExp/property-escapes/generated/Case_Ignorable.js",
+    "test/built-ins/RegExp/property-escapes/generated/Cased.js",
+    "test/built-ins/RegExp/property-escapes/generated/Changes_When_Casefolded.js",
+    "test/built-ins/RegExp/property-escapes/generated/Changes_When_Casemapped.js",
+    "test/built-ins/RegExp/property-escapes/generated/Changes_When_Lowercased.js",
+    "test/built-ins/RegExp/property-escapes/generated/Changes_When_NFKC_Casefolded.js",
+    "test/built-ins/RegExp/property-escapes/generated/Changes_When_Titlecased.js",
+    "test/built-ins/RegExp/property-escapes/generated/Changes_When_Uppercased.js",
+    "test/built-ins/RegExp/property-escapes/generated/Dash.js",
+    "test/built-ins/RegExp/property-escapes/generated/Default_Ignorable_Code_Point.js",
+    "test/built-ins/RegExp/property-escapes/generated/Deprecated.js",
+    "test/built-ins/RegExp/property-escapes/generated/Diacritic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Emoji.js",
+    "test/built-ins/RegExp/property-escapes/generated/Emoji_Component.js",
+    "test/built-ins/RegExp/property-escapes/generated/Emoji_Modifier.js",
+    "test/built-ins/RegExp/property-escapes/generated/Emoji_Modifier_Base.js",
+    "test/built-ins/RegExp/property-escapes/generated/Emoji_Presentation.js",
+    "test/built-ins/RegExp/property-escapes/generated/Extended_Pictographic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Extender.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Cased_Letter.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Close_Punctuation.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Connector_Punctuation.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Control.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Currency_Symbol.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Dash_Punctuation.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Decimal_Number.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Enclosing_Mark.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Final_Punctuation.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Format.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Initial_Punctuation.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Letter.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Letter_Number.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Line_Separator.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Lowercase_Letter.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Mark.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Math_Symbol.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Modifier_Letter.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Modifier_Symbol.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Nonspacing_Mark.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Number.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Open_Punctuation.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Other.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Other_Letter.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Other_Number.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Other_Punctuation.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Other_Symbol.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Paragraph_Separator.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Private_Use.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Punctuation.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Separator.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Space_Separator.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Spacing_Mark.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Surrogate.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Symbol.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Titlecase_Letter.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Unassigned.js",
+    "test/built-ins/RegExp/property-escapes/generated/General_Category_-_Uppercase_Letter.js",
+    "test/built-ins/RegExp/property-escapes/generated/Grapheme_Base.js",
+    "test/built-ins/RegExp/property-escapes/generated/Grapheme_Extend.js",
+    "test/built-ins/RegExp/property-escapes/generated/Hex_Digit.js",
+    "test/built-ins/RegExp/property-escapes/generated/IDS_Binary_Operator.js",
+    "test/built-ins/RegExp/property-escapes/generated/IDS_Trinary_Operator.js",
+    "test/built-ins/RegExp/property-escapes/generated/ID_Continue.js",
+    "test/built-ins/RegExp/property-escapes/generated/ID_Start.js",
+    "test/built-ins/RegExp/property-escapes/generated/Ideographic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Join_Control.js",
+    "test/built-ins/RegExp/property-escapes/generated/Logical_Order_Exception.js",
+    "test/built-ins/RegExp/property-escapes/generated/Lowercase.js",
+    "test/built-ins/RegExp/property-escapes/generated/Math.js",
+    "test/built-ins/RegExp/property-escapes/generated/Noncharacter_Code_Point.js",
+    "test/built-ins/RegExp/property-escapes/generated/Pattern_Syntax.js",
+    "test/built-ins/RegExp/property-escapes/generated/Pattern_White_Space.js",
+    "test/built-ins/RegExp/property-escapes/generated/Quotation_Mark.js",
+    "test/built-ins/RegExp/property-escapes/generated/Radical.js",
+    "test/built-ins/RegExp/property-escapes/generated/Regional_Indicator.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Adlam.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Ahom.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Anatolian_Hieroglyphs.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Arabic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Armenian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Avestan.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Balinese.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Bamum.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Bassa_Vah.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Batak.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Bengali.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Bhaiksuki.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Bopomofo.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Brahmi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Braille.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Buginese.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Buhid.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Canadian_Aboriginal.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Carian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Caucasian_Albanian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Chakma.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Cham.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Cherokee.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Chorasmian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Common.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Coptic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Cuneiform.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Cypriot.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Cypro_Minoan.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Cyrillic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Deseret.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Devanagari.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Dives_Akuru.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Dogra.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Duployan.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Egyptian_Hieroglyphs.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Elbasan.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Elymaic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Ethiopic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Georgian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Glagolitic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Gothic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Grantha.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Greek.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Gujarati.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Gunjala_Gondi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Gurmukhi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Han.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Hangul.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Hanifi_Rohingya.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Hanunoo.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Hatran.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Hebrew.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Hiragana.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Imperial_Aramaic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Inherited.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Inscriptional_Pahlavi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Inscriptional_Parthian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Javanese.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Kaithi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Kannada.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Katakana.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Kawi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Kayah_Li.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Kharoshthi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Khitan_Small_Script.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Khmer.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Khojki.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Khudawadi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Lao.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Latin.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Lepcha.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Limbu.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Linear_A.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Linear_B.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Lisu.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Lycian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Lydian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Mahajani.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Makasar.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Malayalam.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Mandaic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Manichaean.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Marchen.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Masaram_Gondi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Medefaidrin.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Meetei_Mayek.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Mende_Kikakui.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Meroitic_Cursive.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Meroitic_Hieroglyphs.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Miao.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Modi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Mongolian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Mro.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Multani.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Myanmar.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Nabataean.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Nag_Mundari.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Nandinagari.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_New_Tai_Lue.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Newa.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Nko.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Nushu.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Nyiakeng_Puachue_Hmong.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Ogham.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Ol_Chiki.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Old_Hungarian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Old_Italic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Old_North_Arabian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Old_Permic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Old_Persian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Old_Sogdian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Old_South_Arabian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Old_Turkic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Old_Uyghur.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Oriya.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Osage.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Osmanya.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Pahawh_Hmong.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Palmyrene.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Pau_Cin_Hau.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Phags_Pa.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Phoenician.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Psalter_Pahlavi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Rejang.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Runic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Samaritan.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Saurashtra.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Sharada.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Shavian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Siddham.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_SignWriting.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Sinhala.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Sogdian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Sora_Sompeng.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Soyombo.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Sundanese.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Syloti_Nagri.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Syriac.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Tagalog.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Tagbanwa.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Tai_Le.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Tai_Tham.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Tai_Viet.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Takri.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Tamil.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Tangsa.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Tangut.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Telugu.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Thaana.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Thai.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Tibetan.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Tifinagh.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Tirhuta.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Toto.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Ugaritic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Vai.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Vithkuqi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Wancho.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Warang_Citi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Yezidi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Yi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_-_Zanabazar_Square.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Adlam.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Ahom.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Anatolian_Hieroglyphs.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Arabic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Armenian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Avestan.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Balinese.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Bamum.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Bassa_Vah.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Batak.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Bengali.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Bhaiksuki.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Bopomofo.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Brahmi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Braille.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Buginese.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Buhid.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Canadian_Aboriginal.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Carian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Caucasian_Albanian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Chakma.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Cham.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Cherokee.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Chorasmian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Common.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Coptic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Cuneiform.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Cypriot.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Cypro_Minoan.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Cyrillic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Deseret.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Devanagari.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Dives_Akuru.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Dogra.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Duployan.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Egyptian_Hieroglyphs.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Elbasan.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Elymaic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Ethiopic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Georgian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Glagolitic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Gothic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Grantha.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Greek.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Gujarati.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Gunjala_Gondi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Gurmukhi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Han.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Hangul.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Hanifi_Rohingya.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Hanunoo.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Hatran.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Hebrew.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Hiragana.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Imperial_Aramaic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Inherited.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Inscriptional_Pahlavi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Inscriptional_Parthian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Javanese.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Kaithi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Kannada.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Katakana.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Kawi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Kayah_Li.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Kharoshthi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Khitan_Small_Script.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Khmer.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Khojki.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Khudawadi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Lao.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Latin.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Lepcha.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Limbu.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Linear_A.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Linear_B.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Lisu.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Lycian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Lydian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Mahajani.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Makasar.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Malayalam.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Mandaic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Manichaean.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Marchen.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Masaram_Gondi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Medefaidrin.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Meetei_Mayek.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Mende_Kikakui.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Meroitic_Cursive.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Meroitic_Hieroglyphs.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Miao.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Modi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Mongolian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Mro.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Multani.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Myanmar.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Nabataean.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Nag_Mundari.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Nandinagari.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_New_Tai_Lue.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Newa.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Nko.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Nushu.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Nyiakeng_Puachue_Hmong.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Ogham.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Ol_Chiki.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_Hungarian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_Italic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_North_Arabian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_Permic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_Persian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_Sogdian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_South_Arabian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_Turkic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_Uyghur.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Oriya.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Osage.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Osmanya.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Pahawh_Hmong.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Palmyrene.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Pau_Cin_Hau.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Phags_Pa.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Phoenician.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Psalter_Pahlavi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Rejang.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Runic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Samaritan.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Saurashtra.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Sharada.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Shavian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Siddham.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_SignWriting.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Sinhala.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Sogdian.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Sora_Sompeng.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Soyombo.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Sundanese.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Syloti_Nagri.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Syriac.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tagalog.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tagbanwa.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tai_Le.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tai_Tham.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tai_Viet.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Takri.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tamil.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tangsa.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tangut.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Telugu.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Thaana.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Thai.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tibetan.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tifinagh.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tirhuta.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Toto.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Ugaritic.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Vai.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Vithkuqi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Wancho.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Warang_Citi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Yezidi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Yi.js",
+    "test/built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Zanabazar_Square.js",
+    "test/built-ins/RegExp/property-escapes/generated/Sentence_Terminal.js",
+    "test/built-ins/RegExp/property-escapes/generated/Soft_Dotted.js",
+    "test/built-ins/RegExp/property-escapes/generated/Terminal_Punctuation.js",
+    "test/built-ins/RegExp/property-escapes/generated/Unified_Ideograph.js",
+    "test/built-ins/RegExp/property-escapes/generated/Uppercase.js",
+    "test/built-ins/RegExp/property-escapes/generated/Variation_Selector.js",
+    "test/built-ins/RegExp/property-escapes/generated/White_Space.js",
+    "test/built-ins/RegExp/property-escapes/generated/XID_Continue.js",
+    "test/built-ins/RegExp/property-escapes/generated/XID_Start.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-In-prefix-Block-implicit-negated.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-In-prefix-Block-implicit.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-In-prefix-Script-negated.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-In-prefix-Script.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-Is-prefix-Script-negated.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-Is-prefix-Script.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-circumflex-negation-negated.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-circumflex-negation.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-empty-negated.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-empty.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-invalid-negated.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-invalid.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-no-braces-negated.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-no-braces-value-negated.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-no-braces-value.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-separator-and-value-only-negated.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-separator-and-value-only.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-separator-negated.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-separator-only-negated.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-separator-only.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-separator.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-unclosed-negated.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-unopened-negated.js",
+    "test/built-ins/RegExp/property-escapes/grammar-extension-unopened.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-01-negated.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-01.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-02-negated.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-02.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-03-negated.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-03.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-04-negated.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-04.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-05-negated.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-05.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-06-negated.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-06.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-07-negated.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-07.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-08-negated.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-08.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-09-negated.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-09.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-10-negated.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-10.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-11-negated.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-11.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-12-negated.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-12.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-13-negated.js",
+    "test/built-ins/RegExp/property-escapes/loose-matching-13.js",
+    "test/built-ins/RegExp/property-escapes/non-binary-property-without-value-General_Category-equals-negated.js",
+    "test/built-ins/RegExp/property-escapes/non-binary-property-without-value-General_Category-negated.js",
+    "test/built-ins/RegExp/property-escapes/non-binary-property-without-value-Script-equals-negated.js",
+    "test/built-ins/RegExp/property-escapes/non-binary-property-without-value-Script-equals.js",
+    "test/built-ins/RegExp/property-escapes/non-binary-property-without-value-Script-negated.js",
+    "test/built-ins/RegExp/property-escapes/non-binary-property-without-value-Script.js",
+    "test/built-ins/RegExp/property-escapes/non-binary-property-without-value-Script_Extensions-equals-negated.js",
+    "test/built-ins/RegExp/property-escapes/non-binary-property-without-value-Script_Extensions-equals.js",
+    "test/built-ins/RegExp/property-escapes/non-binary-property-without-value-Script_Extensions-negated.js",
+    "test/built-ins/RegExp/property-escapes/non-binary-property-without-value-Script_Extensions.js",
+    "test/built-ins/RegExp/property-escapes/non-existent-binary-property-negated.js",
+    "test/built-ins/RegExp/property-escapes/non-existent-binary-property.js",
+    "test/built-ins/RegExp/property-escapes/non-existent-property-and-value-negated.js",
+    "test/built-ins/RegExp/property-escapes/non-existent-property-and-value.js",
+    "test/built-ins/RegExp/property-escapes/non-existent-property-existing-value-negated.js",
+    "test/built-ins/RegExp/property-escapes/non-existent-property-existing-value.js",
+    "test/built-ins/RegExp/property-escapes/non-existent-property-value-General_Category-negated.js",
+    "test/built-ins/RegExp/property-escapes/non-existent-property-value-Script-negated.js",
+    "test/built-ins/RegExp/property-escapes/non-existent-property-value-Script.js",
+    "test/built-ins/RegExp/property-escapes/non-existent-property-value-Script_Extensions-negated.js",
+    "test/built-ins/RegExp/property-escapes/non-existent-property-value-Script_Extensions.js",
+    "test/built-ins/RegExp/property-escapes/non-existent-property-value-general-category.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Composition_Exclusion-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Composition_Exclusion.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFC-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFC.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFD-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFD.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFKC-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFKC.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFKD-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFKD.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-FC_NFKC_Closure-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-FC_NFKC_Closure.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Full_Composition_Exclusion-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Full_Composition_Exclusion.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Grapheme_Link-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Grapheme_Link.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Hyphen-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Hyphen.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Alphabetic-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Alphabetic.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Default_Ignorable_Code_Point-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Default_Ignorable_Code_Point.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Grapheme_Extend-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Grapheme_Extend.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_ID_Continue-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_ID_Continue.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_ID_Start-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_ID_Start.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Lowercase-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Lowercase.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Math-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Math.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Uppercase-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Uppercase.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Prepended_Concatenation_Mark-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-binary-property-Prepended_Concatenation_Mark.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-property-Block-with-value-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-property-Block-with-value.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-property-Line_Break-negated.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-property-Line_Break-with-value.js",
+    "test/built-ins/RegExp/property-escapes/unsupported-property-Line_Break.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/[--\\p{Hex}]/u": {
+      "error": {
+        "message": "Invalid regular expression: /[--\\p{Hex}]/u: Invalid character class",
+        "index": 11
+      }
+    },
+    "/[\\P{invalid}]/u": {
+      "error": {
+        "message": "Invalid regular expression: /[\\P{invalid}]/u: Invalid property name",
+        "index": 12
+      }
+    },
+    "/[\\P{}]/u": {
+      "error": {
+        "message": "Invalid regular expression: /[\\P{}]/u: Invalid property name",
+        "index": 5
+      }
+    },
+    "/[\\p{Hex}--]/u": {
+      "error": {
+        "message": "Invalid regular expression: /[\\p{Hex}--]/u: Invalid character class",
+        "index": 11
+      }
+    },
+    "/[\\p{Hex}-\\uFFFF]/u": {
+      "error": {
+        "message": "Invalid regular expression: /[\\p{Hex}-\\uFFFF]/u: Invalid character class",
+        "index": 16
+      }
+    },
+    "/[\\p{Hex}\\P{Hex}]/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/[\\p{Hex}\\P{Hex}]/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "[\\p{Hex}\\P{Hex}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "[\\p{Hex}\\P{Hex}]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 17,
+                  "raw": "[\\p{Hex}\\P{Hex}]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterSet",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 9,
+                      "raw": "\\p{Hex}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "Hex",
+                      "value": null,
+                      "negate": false
+                    },
+                    {
+                      "type": "CharacterSet",
+                      "parent": "♻️../..",
+                      "start": 9,
+                      "end": 16,
+                      "raw": "\\P{Hex}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "Hex",
+                      "value": null,
+                      "negate": true
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\p{Hex}]/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/[\\p{Hex}]/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "[\\p{Hex}]",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "[\\p{Hex}]",
+              "elements": [
+                {
+                  "type": "CharacterClass",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 10,
+                  "raw": "[\\p{Hex}]",
+                  "unicodeSets": false,
+                  "negate": false,
+                  "elements": [
+                    {
+                      "type": "CharacterSet",
+                      "parent": "♻️../..",
+                      "start": 2,
+                      "end": 9,
+                      "raw": "\\p{Hex}",
+                      "kind": "property",
+                      "strings": false,
+                      "key": "Hex",
+                      "value": null,
+                      "negate": false
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/[\\p{invalid}]/u": {
+      "error": {
+        "message": "Invalid regular expression: /[\\p{invalid}]/u: Invalid property name",
+        "index": 12
+      }
+    },
+    "/[\\p{}]/u": {
+      "error": {
+        "message": "Invalid regular expression: /[\\p{}]/u: Invalid property name",
+        "index": 5
+      }
+    },
+    "/[\\uFFFF-\\p{Hex}]/u": {
+      "error": {
+        "message": "Invalid regular expression: /[\\uFFFF-\\p{Hex}]/u: Invalid character class",
+        "index": 16
+      }
+    },
+    "/\\P/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P/u: Invalid property name",
+        "index": 3
+      }
+    },
+    "/\\PL/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\PL/u: Invalid property name",
+        "index": 3
+      }
+    },
+    "/\\P{ General_Category=Uppercase_Letter }/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{ General_Category=Uppercase_Letter }/u: Invalid property name",
+        "index": 4
+      }
+    },
+    "/\\P{ Lowercase }/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{ Lowercase }/u: Invalid property name",
+        "index": 4
+      }
+    },
+    "/\\P{/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{/u: Invalid property name",
+        "index": 4
+      }
+    },
+    "/\\P{=Letter}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{=Letter}/u: Invalid property name",
+        "index": 4
+      }
+    },
+    "/\\P{=}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{=}/u: Invalid property name",
+        "index": 4
+      }
+    },
+    "/\\P{ANY}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{ANY}/u: Invalid property name",
+        "index": 7
+      }
+    },
+    "/\\P{ASCII=F}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{ASCII=F}/u: Invalid property name",
+        "index": 11
+      }
+    },
+    "/\\P{ASCII=Invalid}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{ASCII=Invalid}/u: Invalid property name",
+        "index": 17
+      }
+    },
+    "/\\P{ASCII=No}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{ASCII=No}/u: Invalid property name",
+        "index": 12
+      }
+    },
+    "/\\P{ASCII=N}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{ASCII=N}/u: Invalid property name",
+        "index": 11
+      }
+    },
+    "/\\P{ASCII=T}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{ASCII=T}/u: Invalid property name",
+        "index": 11
+      }
+    },
+    "/\\P{ASCII=Yes}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{ASCII=Yes}/u: Invalid property name",
+        "index": 13
+      }
+    },
+    "/\\P{ASCII=Y}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{ASCII=Y}/u: Invalid property name",
+        "index": 11
+      }
+    },
+    "/\\P{ASSIGNED}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{ASSIGNED}/u: Invalid property name",
+        "index": 12
+      }
+    },
+    "/\\P{Any}/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/\\P{Any}/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "\\P{Any}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "\\P{Any}",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 8,
+                  "raw": "\\P{Any}",
+                  "kind": "property",
+                  "strings": false,
+                  "key": "Any",
+                  "value": null,
+                  "negate": true
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/\\P{Ascii}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Ascii}/u: Invalid property name",
+        "index": 9
+      }
+    },
+    "/\\P{Block=Adlam}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Block=Adlam}/u: Invalid property name",
+        "index": 15
+      }
+    },
+    "/\\P{Composition_Exclusion}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Composition_Exclusion}/u: Invalid property name",
+        "index": 25
+      }
+    },
+    "/\\P{Expands_On_NFC}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Expands_On_NFC}/u: Invalid property name",
+        "index": 18
+      }
+    },
+    "/\\P{Expands_On_NFD}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Expands_On_NFD}/u: Invalid property name",
+        "index": 18
+      }
+    },
+    "/\\P{Expands_On_NFKC}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Expands_On_NFKC}/u: Invalid property name",
+        "index": 19
+      }
+    },
+    "/\\P{Expands_On_NFKD}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Expands_On_NFKD}/u: Invalid property name",
+        "index": 19
+      }
+    },
+    "/\\P{FC_NFKC_Closure}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{FC_NFKC_Closure}/u: Invalid property name",
+        "index": 19
+      }
+    },
+    "/\\P{Full_Composition_Exclusion}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Full_Composition_Exclusion}/u: Invalid property name",
+        "index": 30
+      }
+    },
+    "/\\P{General_Category = Uppercase_Letter}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{General_Category = Uppercase_Letter}/u: Invalid property name",
+        "index": 20
+      }
+    },
+    "/\\P{General_Category:Letter}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{General_Category:Letter}/u: Invalid property name",
+        "index": 20
+      }
+    },
+    "/\\P{General_Category=}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{General_Category=}/u: Invalid property name",
+        "index": 20
+      }
+    },
+    "/\\P{General_Category}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{General_Category}/u: Invalid property name",
+        "index": 20
+      }
+    },
+    "/\\P{Grapheme_Link}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Grapheme_Link}/u: Invalid property name",
+        "index": 17
+      }
+    },
+    "/\\P{Hyphen}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Hyphen}/u: Invalid property name",
+        "index": 10
+      }
+    },
+    "/\\P{InAdlam}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{InAdlam}/u: Invalid property name",
+        "index": 11
+      }
+    },
+    "/\\P{InScript=Adlam}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{InScript=Adlam}/u: Invalid property name",
+        "index": 18
+      }
+    },
+    "/\\P{IsScript=Adlam}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{IsScript=Adlam}/u: Invalid property name",
+        "index": 18
+      }
+    },
+    "/\\P{Line_Break=Alphabetic}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Line_Break=Alphabetic}/u: Invalid property name",
+        "index": 25
+      }
+    },
+    "/\\P{Line_Breakz=Alphabetic}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Line_Breakz=Alphabetic}/u: Invalid property name",
+        "index": 26
+      }
+    },
+    "/\\P{Line_Breakz=WAT}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Line_Breakz=WAT}/u: Invalid property name",
+        "index": 19
+      }
+    },
+    "/\\P{Other_Alphabetic}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Other_Alphabetic}/u: Invalid property name",
+        "index": 20
+      }
+    },
+    "/\\P{Other_Default_Ignorable_Code_Point}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Other_Default_Ignorable_Code_Point}/u: Invalid property name",
+        "index": 38
+      }
+    },
+    "/\\P{Other_Grapheme_Extend}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Other_Grapheme_Extend}/u: Invalid property name",
+        "index": 25
+      }
+    },
+    "/\\P{Other_ID_Continue}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Other_ID_Continue}/u: Invalid property name",
+        "index": 21
+      }
+    },
+    "/\\P{Other_ID_Start}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Other_ID_Start}/u: Invalid property name",
+        "index": 18
+      }
+    },
+    "/\\P{Other_Lowercase}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Other_Lowercase}/u: Invalid property name",
+        "index": 19
+      }
+    },
+    "/\\P{Other_Math}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Other_Math}/u: Invalid property name",
+        "index": 14
+      }
+    },
+    "/\\P{Other_Uppercase}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Other_Uppercase}/u: Invalid property name",
+        "index": 19
+      }
+    },
+    "/\\P{Prepended_Concatenation_Mark}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Prepended_Concatenation_Mark}/u: Invalid property name",
+        "index": 32
+      }
+    },
+    "/\\P{Script=}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Script=}/u: Invalid property name",
+        "index": 10
+      }
+    },
+    "/\\P{Script_Extensions=}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Script_Extensions=}/u: Invalid property name",
+        "index": 21
+      }
+    },
+    "/\\P{Script_Extensions}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Script_Extensions}/u: Invalid property name",
+        "index": 21
+      }
+    },
+    "/\\P{Script}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Script}/u: Invalid property name",
+        "index": 10
+      }
+    },
+    "/\\P{UnknownBinaryProperty}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{UnknownBinaryProperty}/u: Invalid property name",
+        "index": 25
+      }
+    },
+    "/\\P{^General_Category=Letter}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{^General_Category=Letter}/u: Invalid property name",
+        "index": 4
+      }
+    },
+    "/\\P{_-_lOwEr_C-A_S-E_-_}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{_-_lOwEr_C-A_S-E_-_}/u: Invalid property name",
+        "index": 5
+      }
+    },
+    "/\\P{any}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{any}/u: Invalid property name",
+        "index": 7
+      }
+    },
+    "/\\P{ascii}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{ascii}/u: Invalid property name",
+        "index": 9
+      }
+    },
+    "/\\P{assigned}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{assigned}/u: Invalid property name",
+        "index": 12
+      }
+    },
+    "/\\P{gC=uppercase_letter}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{gC=uppercase_letter}/u: Invalid property name",
+        "index": 23
+      }
+    },
+    "/\\P{gc=uppercaseletter}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{gc=uppercaseletter}/u: Invalid property name",
+        "index": 22
+      }
+    },
+    "/\\P{lowercase}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{lowercase}/u: Invalid property name",
+        "index": 13
+      }
+    },
+    "/\\P}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\P}/u: Invalid property name",
+        "index": 3
+      }
+    },
+    "/\\\\P{General_Category=WAT}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\\\P{General_Category=WAT}/u: Incomplete quantifier",
+        "index": 5
+      }
+    },
+    "/\\\\P{Script=FooBarBazInvalid}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\\\P{Script=FooBarBazInvalid}/u: Incomplete quantifier",
+        "index": 5
+      }
+    },
+    "/\\\\P{Script_Extensions=H_e_h}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\\\P{Script_Extensions=H_e_h}/u: Incomplete quantifier",
+        "index": 5
+      }
+    },
+    "/\\\\p{General_Category=WAT}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\\\p{General_Category=WAT}/u: Incomplete quantifier",
+        "index": 5
+      }
+    },
+    "/\\\\p{Script=FooBarBazInvalid}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\\\p{Script=FooBarBazInvalid}/u: Incomplete quantifier",
+        "index": 5
+      }
+    },
+    "/\\\\p{Script_Extensions=H_e_h}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\\\p{Script_Extensions=H_e_h}/u: Incomplete quantifier",
+        "index": 5
+      }
+    },
+    "/\\pL/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\pL/u: Invalid property name",
+        "index": 3
+      }
+    },
+    "/\\p{ General_Category=Uppercase_Letter }/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{ General_Category=Uppercase_Letter }/u: Invalid property name",
+        "index": 4
+      }
+    },
+    "/\\p{ Lowercase }/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{ Lowercase }/u: Invalid property name",
+        "index": 4
+      }
+    },
+    "/\\p{=Letter}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{=Letter}/u: Invalid property name",
+        "index": 4
+      }
+    },
+    "/\\p{=}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{=}/u: Invalid property name",
+        "index": 4
+      }
+    },
+    "/\\p{ANY}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{ANY}/u: Invalid property name",
+        "index": 7
+      }
+    },
+    "/\\p{ASCII=F}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{ASCII=F}/u: Invalid property name",
+        "index": 11
+      }
+    },
+    "/\\p{ASCII=Invalid}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{ASCII=Invalid}/u: Invalid property name",
+        "index": 17
+      }
+    },
+    "/\\p{ASCII=No}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{ASCII=No}/u: Invalid property name",
+        "index": 12
+      }
+    },
+    "/\\p{ASCII=N}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{ASCII=N}/u: Invalid property name",
+        "index": 11
+      }
+    },
+    "/\\p{ASCII=T}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{ASCII=T}/u: Invalid property name",
+        "index": 11
+      }
+    },
+    "/\\p{ASCII=Yes}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{ASCII=Yes}/u: Invalid property name",
+        "index": 13
+      }
+    },
+    "/\\p{ASCII=Y}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{ASCII=Y}/u: Invalid property name",
+        "index": 11
+      }
+    },
+    "/\\p{ASSIGNED}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{ASSIGNED}/u: Invalid property name",
+        "index": 12
+      }
+    },
+    "/\\p{Ascii}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Ascii}/u: Invalid property name",
+        "index": 9
+      }
+    },
+    "/\\p{Block=Adlam}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Block=Adlam}/u: Invalid property name",
+        "index": 15
+      }
+    },
+    "/\\p{Composition_Exclusion}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Composition_Exclusion}/u: Invalid property name",
+        "index": 25
+      }
+    },
+    "/\\p{Expands_On_NFC}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Expands_On_NFC}/u: Invalid property name",
+        "index": 18
+      }
+    },
+    "/\\p{Expands_On_NFD}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Expands_On_NFD}/u: Invalid property name",
+        "index": 18
+      }
+    },
+    "/\\p{Expands_On_NFKC}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Expands_On_NFKC}/u: Invalid property name",
+        "index": 19
+      }
+    },
+    "/\\p{Expands_On_NFKD}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Expands_On_NFKD}/u: Invalid property name",
+        "index": 19
+      }
+    },
+    "/\\p{FC_NFKC_Closure}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{FC_NFKC_Closure}/u: Invalid property name",
+        "index": 19
+      }
+    },
+    "/\\p{Full_Composition_Exclusion}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Full_Composition_Exclusion}/u: Invalid property name",
+        "index": 30
+      }
+    },
+    "/\\p{General_Category = Uppercase_Letter}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{General_Category = Uppercase_Letter}/u: Invalid property name",
+        "index": 20
+      }
+    },
+    "/\\p{General_Category:Letter}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{General_Category:Letter}/u: Invalid property name",
+        "index": 20
+      }
+    },
+    "/\\p{Grapheme_Link}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Grapheme_Link}/u: Invalid property name",
+        "index": 17
+      }
+    },
+    "/\\p{Hyphen}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Hyphen}/u: Invalid property name",
+        "index": 10
+      }
+    },
+    "/\\p{InAdlam}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{InAdlam}/u: Invalid property name",
+        "index": 11
+      }
+    },
+    "/\\p{InScript=Adlam}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{InScript=Adlam}/u: Invalid property name",
+        "index": 18
+      }
+    },
+    "/\\p{IsScript=Adlam}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{IsScript=Adlam}/u: Invalid property name",
+        "index": 18
+      }
+    },
+    "/\\p{Line_Break=Alphabetic}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Line_Break=Alphabetic}/u: Invalid property name",
+        "index": 25
+      }
+    },
+    "/\\p{Line_Breakz=Alphabetic}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Line_Breakz=Alphabetic}/u: Invalid property name",
+        "index": 26
+      }
+    },
+    "/\\p{Line_Breakz=WAT}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Line_Breakz=WAT}/u: Invalid property name",
+        "index": 19
+      }
+    },
+    "/\\p{Line_Break}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Line_Break}/u: Invalid property name",
+        "index": 14
+      }
+    },
+    "/\\p{Other_Alphabetic}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Other_Alphabetic}/u: Invalid property name",
+        "index": 20
+      }
+    },
+    "/\\p{Other_Default_Ignorable_Code_Point}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Other_Default_Ignorable_Code_Point}/u: Invalid property name",
+        "index": 38
+      }
+    },
+    "/\\p{Other_Grapheme_Extend}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Other_Grapheme_Extend}/u: Invalid property name",
+        "index": 25
+      }
+    },
+    "/\\p{Other_ID_Continue}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Other_ID_Continue}/u: Invalid property name",
+        "index": 21
+      }
+    },
+    "/\\p{Other_ID_Start}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Other_ID_Start}/u: Invalid property name",
+        "index": 18
+      }
+    },
+    "/\\p{Other_Lowercase}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Other_Lowercase}/u: Invalid property name",
+        "index": 19
+      }
+    },
+    "/\\p{Other_Math}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Other_Math}/u: Invalid property name",
+        "index": 14
+      }
+    },
+    "/\\p{Other_Uppercase}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Other_Uppercase}/u: Invalid property name",
+        "index": 19
+      }
+    },
+    "/\\p{Prepended_Concatenation_Mark}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Prepended_Concatenation_Mark}/u: Invalid property name",
+        "index": 32
+      }
+    },
+    "/\\p{Script=}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Script=}/u: Invalid property name",
+        "index": 10
+      }
+    },
+    "/\\p{Script_Extensions=}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Script_Extensions=}/u: Invalid property name",
+        "index": 21
+      }
+    },
+    "/\\p{Script_Extensions}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Script_Extensions}/u: Invalid property name",
+        "index": 21
+      }
+    },
+    "/\\p{Script}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Script}/u: Invalid property name",
+        "index": 10
+      }
+    },
+    "/\\p{UnknownBinaryProperty}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{UnknownBinaryProperty}/u: Invalid property name",
+        "index": 25
+      }
+    },
+    "/\\p{^General_Category=Letter}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{^General_Category=Letter}/u: Invalid property name",
+        "index": 4
+      }
+    },
+    "/\\p{_-_lOwEr_C-A_S-E_-_}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{_-_lOwEr_C-A_S-E_-_}/u: Invalid property name",
+        "index": 5
+      }
+    },
+    "/\\p{any}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{any}/u: Invalid property name",
+        "index": 7
+      }
+    },
+    "/\\p{ascii}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{ascii}/u: Invalid property name",
+        "index": 9
+      }
+    },
+    "/\\p{assigned}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{assigned}/u: Invalid property name",
+        "index": 12
+      }
+    },
+    "/\\p{gC=uppercase_letter}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{gC=uppercase_letter}/u: Invalid property name",
+        "index": 23
+      }
+    },
+    "/\\p{gc=uppercaseletter}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{gc=uppercaseletter}/u: Invalid property name",
+        "index": 22
+      }
+    },
+    "/\\p{lowercase}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{lowercase}/u: Invalid property name",
+        "index": 13
+      }
+    },
+    "/\\p}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p}/u: Invalid property name",
+        "index": 3
+      }
+    },
+    "/^\\P{AHex}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{AHex}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{AHex}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{AHex}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{AHex}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{AHex}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "AHex",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{ASCII_Hex_Digit}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{ASCII_Hex_Digit}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{ASCII_Hex_Digit}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{ASCII_Hex_Digit}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{ASCII_Hex_Digit}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{ASCII_Hex_Digit}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "ASCII_Hex_Digit",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{ASCII}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{ASCII}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{ASCII}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{ASCII}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{ASCII}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{ASCII}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "ASCII",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Alphabetic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{Alphabetic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{Alphabetic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{Alphabetic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{Alphabetic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{Alphabetic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Alphabetic",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Alpha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{Alpha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{Alpha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{Alpha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{Alpha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{Alpha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Alpha",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Assigned}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{Assigned}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{Assigned}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{Assigned}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{Assigned}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{Assigned}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Assigned",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Bidi_Control}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Bidi_Control}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Bidi_Control}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Bidi_Control}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Bidi_Control}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Bidi_Control}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Bidi_Control",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Bidi_C}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{Bidi_C}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{Bidi_C}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{Bidi_C}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{Bidi_C}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{Bidi_C}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Bidi_C",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Bidi_Mirrored}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Bidi_Mirrored}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Bidi_Mirrored}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Bidi_Mirrored}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Bidi_Mirrored}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Bidi_Mirrored}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Bidi_Mirrored",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Bidi_M}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{Bidi_M}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{Bidi_M}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{Bidi_M}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{Bidi_M}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{Bidi_M}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Bidi_M",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{CI}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{CI}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{CI}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{CI}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{CI}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{CI}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CI",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{CWCF}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{CWCF}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{CWCF}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{CWCF}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{CWCF}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{CWCF}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CWCF",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{CWCM}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{CWCM}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{CWCM}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{CWCM}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{CWCM}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{CWCM}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CWCM",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{CWKCF}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{CWKCF}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{CWKCF}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{CWKCF}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{CWKCF}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{CWKCF}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CWKCF",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{CWL}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\P{CWL}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\P{CWL}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\P{CWL}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\P{CWL}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\P{CWL}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CWL",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{CWT}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\P{CWT}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\P{CWT}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\P{CWT}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\P{CWT}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\P{CWT}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CWT",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{CWU}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\P{CWU}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\P{CWU}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\P{CWU}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\P{CWU}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\P{CWU}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CWU",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Case_Ignorable}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Case_Ignorable}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Case_Ignorable}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Case_Ignorable}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Case_Ignorable}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Case_Ignorable}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Case_Ignorable",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Cased_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Cased_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Cased_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Cased_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Cased_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Cased_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cased_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Cased}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{Cased}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{Cased}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{Cased}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{Cased}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{Cased}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Cased",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Cc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Cc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Cc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Cc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Cc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Cc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Cf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Cf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Cf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Cf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Cf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Cf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cf",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Changes_When_Casefolded}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Changes_When_Casefolded}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Changes_When_Casefolded}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Changes_When_Casefolded}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Changes_When_Casefolded}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Changes_When_Casefolded}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Changes_When_Casefolded",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Changes_When_Casemapped}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Changes_When_Casemapped}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Changes_When_Casemapped}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Changes_When_Casemapped}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Changes_When_Casemapped}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Changes_When_Casemapped}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Changes_When_Casemapped",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Changes_When_Lowercased}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Changes_When_Lowercased}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Changes_When_Lowercased}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Changes_When_Lowercased}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Changes_When_Lowercased}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Changes_When_Lowercased}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Changes_When_Lowercased",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Changes_When_NFKC_Casefolded}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Changes_When_NFKC_Casefolded}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Changes_When_NFKC_Casefolded}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Changes_When_NFKC_Casefolded}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Changes_When_NFKC_Casefolded}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Changes_When_NFKC_Casefolded}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Changes_When_NFKC_Casefolded",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Changes_When_Titlecased}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Changes_When_Titlecased}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Changes_When_Titlecased}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Changes_When_Titlecased}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Changes_When_Titlecased}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Changes_When_Titlecased}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Changes_When_Titlecased",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Changes_When_Uppercased}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Changes_When_Uppercased}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Changes_When_Uppercased}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Changes_When_Uppercased}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Changes_When_Uppercased}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Changes_When_Uppercased}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Changes_When_Uppercased",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Close_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Close_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Close_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Close_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Close_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Close_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Close_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Cn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Cn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Cn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Cn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Cn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Cn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Combining_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Combining_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Combining_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Combining_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Combining_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Combining_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Combining_Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Connector_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\P{Connector_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\P{Connector_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\P{Connector_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\P{Connector_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\P{Connector_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Connector_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Control}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{Control}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{Control}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{Control}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{Control}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{Control}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Control",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Co}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Co}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Co}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Co}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Co}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Co}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Co",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Cs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Cs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Cs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Cs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Cs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Cs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Currency_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Currency_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Currency_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Currency_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Currency_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Currency_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Currency_Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{C}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\P{C}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\P{C}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\P{C}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\P{C}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\P{C}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "C",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{DI}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{DI}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{DI}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{DI}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{DI}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{DI}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "DI",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Dash_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Dash_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Dash_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Dash_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Dash_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Dash_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Dash_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Dash}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{Dash}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{Dash}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{Dash}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{Dash}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{Dash}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Dash",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Decimal_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Decimal_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Decimal_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Decimal_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Decimal_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Decimal_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Decimal_Number",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Default_Ignorable_Code_Point}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Default_Ignorable_Code_Point}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Default_Ignorable_Code_Point}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Default_Ignorable_Code_Point}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Default_Ignorable_Code_Point}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Default_Ignorable_Code_Point}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Default_Ignorable_Code_Point",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Deprecated}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{Deprecated}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{Deprecated}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{Deprecated}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{Deprecated}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{Deprecated}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Deprecated",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Dep}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\P{Dep}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\P{Dep}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\P{Dep}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\P{Dep}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\P{Dep}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Dep",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Diacritic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{Diacritic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{Diacritic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{Diacritic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{Diacritic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{Diacritic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Diacritic",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Dia}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\P{Dia}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\P{Dia}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\P{Dia}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\P{Dia}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\P{Dia}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Dia",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{EBase}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{EBase}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{EBase}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{EBase}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{EBase}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{EBase}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "EBase",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{EComp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{EComp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{EComp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{EComp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{EComp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{EComp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "EComp",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{EMod}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{EMod}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{EMod}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{EMod}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{EMod}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{EMod}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "EMod",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{EPres}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{EPres}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{EPres}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{EPres}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{EPres}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{EPres}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "EPres",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Emoji_Component}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Emoji_Component}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Emoji_Component}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Emoji_Component}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Emoji_Component}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Emoji_Component}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Emoji_Component",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Emoji_Modifier_Base}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{Emoji_Modifier_Base}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{Emoji_Modifier_Base}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{Emoji_Modifier_Base}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{Emoji_Modifier_Base}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{Emoji_Modifier_Base}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Emoji_Modifier_Base",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Emoji_Modifier}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Emoji_Modifier}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Emoji_Modifier}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Emoji_Modifier}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Emoji_Modifier}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Emoji_Modifier}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Emoji_Modifier",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Emoji_Presentation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{Emoji_Presentation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{Emoji_Presentation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{Emoji_Presentation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{Emoji_Presentation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{Emoji_Presentation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Emoji_Presentation",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Emoji}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{Emoji}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{Emoji}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{Emoji}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{Emoji}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{Emoji}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Emoji",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Enclosing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Enclosing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Enclosing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Enclosing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Enclosing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Enclosing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Enclosing_Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{ExtPict}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{ExtPict}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{ExtPict}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{ExtPict}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{ExtPict}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{ExtPict}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "ExtPict",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Extended_Pictographic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\P{Extended_Pictographic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\P{Extended_Pictographic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\P{Extended_Pictographic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\P{Extended_Pictographic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\P{Extended_Pictographic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Extended_Pictographic",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Extender}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{Extender}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{Extender}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{Extender}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{Extender}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{Extender}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Extender",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Ext}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\P{Ext}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\P{Ext}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\P{Ext}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\P{Ext}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\P{Ext}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Ext",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Final_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Final_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Final_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Final_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Final_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Final_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Final_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Format}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{Format}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{Format}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{Format}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{Format}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{Format}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Format",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Cased_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{General_Category=Cased_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{General_Category=Cased_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{General_Category=Cased_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{General_Category=Cased_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{General_Category=Cased_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cased_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Cc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Cc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Cc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Cc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Cc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Cc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Cf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Cf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Cf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Cf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Cf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Cf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cf",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Close_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/^\\P{General_Category=Close_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 42,
+          "raw": "^\\P{General_Category=Close_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 42,
+              "raw": "^\\P{General_Category=Close_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 41,
+                  "raw": "\\P{General_Category=Close_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 40,
+                    "raw": "\\P{General_Category=Close_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Close_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 41,
+                  "end": 42,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 43,
+          "end": 44,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Cn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Cn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Cn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Cn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Cn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Cn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Combining_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\P{General_Category=Combining_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\P{General_Category=Combining_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\P{General_Category=Combining_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\P{General_Category=Combining_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\P{General_Category=Combining_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Combining_Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Connector_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 48,
+        "raw": "/^\\P{General_Category=Connector_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 46,
+          "raw": "^\\P{General_Category=Connector_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 46,
+              "raw": "^\\P{General_Category=Connector_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 45,
+                  "raw": "\\P{General_Category=Connector_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 44,
+                    "raw": "\\P{General_Category=Connector_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Connector_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 45,
+                  "end": 46,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 47,
+          "end": 48,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Control}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{General_Category=Control}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{General_Category=Control}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{General_Category=Control}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{General_Category=Control}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{General_Category=Control}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Control",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Co}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Co}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Co}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Co}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Co}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Co}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Co",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Cs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Cs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Cs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Cs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Cs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Cs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Currency_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 42,
+        "raw": "/^\\P{General_Category=Currency_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "^\\P{General_Category=Currency_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "^\\P{General_Category=Currency_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 39,
+                  "raw": "\\P{General_Category=Currency_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 38,
+                    "raw": "\\P{General_Category=Currency_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Currency_Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 39,
+                  "end": 40,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 42,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=C}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{General_Category=C}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{General_Category=C}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{General_Category=C}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{General_Category=C}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{General_Category=C}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "C",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Dash_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\P{General_Category=Dash_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\P{General_Category=Dash_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\P{General_Category=Dash_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\P{General_Category=Dash_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\P{General_Category=Dash_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Dash_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Decimal_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\P{General_Category=Decimal_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\P{General_Category=Decimal_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\P{General_Category=Decimal_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\P{General_Category=Decimal_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\P{General_Category=Decimal_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Decimal_Number",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Enclosing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\P{General_Category=Enclosing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\P{General_Category=Enclosing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\P{General_Category=Enclosing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\P{General_Category=Enclosing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\P{General_Category=Enclosing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Enclosing_Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Final_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/^\\P{General_Category=Final_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 42,
+          "raw": "^\\P{General_Category=Final_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 42,
+              "raw": "^\\P{General_Category=Final_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 41,
+                  "raw": "\\P{General_Category=Final_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 40,
+                    "raw": "\\P{General_Category=Final_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Final_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 41,
+                  "end": 42,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 43,
+          "end": 44,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Format}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{General_Category=Format}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{General_Category=Format}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{General_Category=Format}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{General_Category=Format}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{General_Category=Format}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Format",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Initial_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 46,
+        "raw": "/^\\P{General_Category=Initial_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 44,
+          "raw": "^\\P{General_Category=Initial_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 44,
+              "raw": "^\\P{General_Category=Initial_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 43,
+                  "raw": "\\P{General_Category=Initial_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 42,
+                    "raw": "\\P{General_Category=Initial_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Initial_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 43,
+                  "end": 44,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 45,
+          "end": 46,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=LC}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=LC}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=LC}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=LC}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=LC}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=LC}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "LC",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Letter_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^\\P{General_Category=Letter_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^\\P{General_Category=Letter_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^\\P{General_Category=Letter_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "\\P{General_Category=Letter_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "\\P{General_Category=Letter_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Letter_Number",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{General_Category=Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{General_Category=Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{General_Category=Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{General_Category=Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{General_Category=Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Line_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\P{General_Category=Line_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\P{General_Category=Line_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\P{General_Category=Line_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\P{General_Category=Line_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\P{General_Category=Line_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Line_Separator",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Ll}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Ll}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Ll}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Ll}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Ll}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Ll}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Ll",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Lm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Lm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Lm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Lm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Lm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Lm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Lowercase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\P{General_Category=Lowercase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\P{General_Category=Lowercase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\P{General_Category=Lowercase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\P{General_Category=Lowercase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\P{General_Category=Lowercase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lowercase_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Lo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Lo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Lo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Lo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Lo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Lo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Lt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Lt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Lt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Lt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Lt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Lt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Lu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Lu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Lu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Lu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Lu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Lu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=L}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{General_Category=L}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{General_Category=L}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{General_Category=L}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{General_Category=L}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{General_Category=L}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "L",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\P{General_Category=Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\P{General_Category=Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\P{General_Category=Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\P{General_Category=Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\P{General_Category=Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Math_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{General_Category=Math_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{General_Category=Math_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{General_Category=Math_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{General_Category=Math_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{General_Category=Math_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Math_Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Mc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Mc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Mc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Mc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Mc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Mc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Mc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Me}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Me}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Me}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Me}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Me}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Me}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Me",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Mn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Mn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Mn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Mn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Mn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Mn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Mn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Modifier_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 42,
+        "raw": "/^\\P{General_Category=Modifier_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "^\\P{General_Category=Modifier_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "^\\P{General_Category=Modifier_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 39,
+                  "raw": "\\P{General_Category=Modifier_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 38,
+                    "raw": "\\P{General_Category=Modifier_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Modifier_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 39,
+                  "end": 40,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 42,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Modifier_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 42,
+        "raw": "/^\\P{General_Category=Modifier_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "^\\P{General_Category=Modifier_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "^\\P{General_Category=Modifier_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 39,
+                  "raw": "\\P{General_Category=Modifier_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 38,
+                    "raw": "\\P{General_Category=Modifier_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Modifier_Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 39,
+                  "end": 40,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 42,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=M}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{General_Category=M}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{General_Category=M}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{General_Category=M}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{General_Category=M}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{General_Category=M}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "M",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Nd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Nd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Nd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Nd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Nd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Nd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Nd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Nl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Nl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Nl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Nl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Nl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Nl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Nl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Nonspacing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 42,
+        "raw": "/^\\P{General_Category=Nonspacing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "^\\P{General_Category=Nonspacing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "^\\P{General_Category=Nonspacing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 39,
+                  "raw": "\\P{General_Category=Nonspacing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 38,
+                    "raw": "\\P{General_Category=Nonspacing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Nonspacing_Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 39,
+                  "end": 40,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 42,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=No}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=No}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=No}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=No}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=No}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=No}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "No",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{General_Category=Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{General_Category=Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{General_Category=Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{General_Category=Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{General_Category=Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Number",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=N}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{General_Category=N}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{General_Category=N}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{General_Category=N}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{General_Category=N}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{General_Category=N}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "N",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Open_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\P{General_Category=Open_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\P{General_Category=Open_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\P{General_Category=Open_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\P{General_Category=Open_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\P{General_Category=Open_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Open_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Other_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{General_Category=Other_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{General_Category=Other_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{General_Category=Other_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{General_Category=Other_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{General_Category=Other_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Other_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{General_Category=Other_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{General_Category=Other_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{General_Category=Other_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{General_Category=Other_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{General_Category=Other_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Number",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Other_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/^\\P{General_Category=Other_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 42,
+          "raw": "^\\P{General_Category=Other_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 42,
+              "raw": "^\\P{General_Category=Other_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 41,
+                  "raw": "\\P{General_Category=Other_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 40,
+                    "raw": "\\P{General_Category=Other_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 41,
+                  "end": 42,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 43,
+          "end": 44,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Other_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{General_Category=Other_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{General_Category=Other_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{General_Category=Other_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{General_Category=Other_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{General_Category=Other_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Other}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{General_Category=Other}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{General_Category=Other}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{General_Category=Other}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{General_Category=Other}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{General_Category=Other}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Paragraph_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 46,
+        "raw": "/^\\P{General_Category=Paragraph_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 44,
+          "raw": "^\\P{General_Category=Paragraph_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 44,
+              "raw": "^\\P{General_Category=Paragraph_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 43,
+                  "raw": "\\P{General_Category=Paragraph_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 42,
+                    "raw": "\\P{General_Category=Paragraph_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Paragraph_Separator",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 43,
+                  "end": 44,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 45,
+          "end": 46,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Pc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Pc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Pc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Pc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Pc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Pc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Pd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Pd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Pd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Pd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Pd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Pd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Pe}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Pe}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Pe}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Pe}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Pe}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Pe}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pe",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Pf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Pf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Pf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Pf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Pf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Pf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pf",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Pi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Pi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Pi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Pi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Pi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Pi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Po}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Po}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Po}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Po}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Po}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Po}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Po",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Private_Use}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{General_Category=Private_Use}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{General_Category=Private_Use}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{General_Category=Private_Use}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{General_Category=Private_Use}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{General_Category=Private_Use}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Private_Use",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Ps}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Ps}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Ps}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Ps}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Ps}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Ps}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Ps",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{General_Category=Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{General_Category=Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{General_Category=Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{General_Category=Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{General_Category=Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=P}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{General_Category=P}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{General_Category=P}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{General_Category=P}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{General_Category=P}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{General_Category=P}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "P",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Sc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Sc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Sc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Sc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Sc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Sc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Sc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{General_Category=Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{General_Category=Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{General_Category=Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{General_Category=Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{General_Category=Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Separator",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Sk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Sk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Sk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Sk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Sk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Sk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Sk",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Sm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Sm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Sm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Sm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Sm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Sm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Sm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=So}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=So}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=So}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=So}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=So}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=So}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "So",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Space_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 42,
+        "raw": "/^\\P{General_Category=Space_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "^\\P{General_Category=Space_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "^\\P{General_Category=Space_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 39,
+                  "raw": "\\P{General_Category=Space_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 38,
+                    "raw": "\\P{General_Category=Space_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Space_Separator",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 39,
+                  "end": 40,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 42,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Spacing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{General_Category=Spacing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{General_Category=Spacing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{General_Category=Spacing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{General_Category=Spacing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{General_Category=Spacing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Spacing_Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Surrogate}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{General_Category=Surrogate}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{General_Category=Surrogate}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{General_Category=Surrogate}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{General_Category=Surrogate}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{General_Category=Surrogate}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Surrogate",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{General_Category=Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{General_Category=Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{General_Category=Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{General_Category=Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{General_Category=Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=S}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{General_Category=S}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{General_Category=S}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{General_Category=S}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{General_Category=S}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{General_Category=S}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "S",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Titlecase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\P{General_Category=Titlecase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\P{General_Category=Titlecase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\P{General_Category=Titlecase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\P{General_Category=Titlecase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\P{General_Category=Titlecase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Titlecase_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Unassigned}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{General_Category=Unassigned}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{General_Category=Unassigned}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{General_Category=Unassigned}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{General_Category=Unassigned}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{General_Category=Unassigned}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Unassigned",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Uppercase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\P{General_Category=Uppercase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\P{General_Category=Uppercase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\P{General_Category=Uppercase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\P{General_Category=Uppercase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\P{General_Category=Uppercase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Uppercase_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Zl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Zl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Zl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Zl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Zl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Zl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Zl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Zp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Zp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Zp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Zp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Zp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Zp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Zp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Zs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{General_Category=Zs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{General_Category=Zs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{General_Category=Zs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{General_Category=Zs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{General_Category=Zs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Zs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=Z}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{General_Category=Z}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{General_Category=Z}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{General_Category=Z}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{General_Category=Z}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{General_Category=Z}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Z",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=cntrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{General_Category=cntrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{General_Category=cntrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{General_Category=cntrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{General_Category=cntrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{General_Category=cntrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "cntrl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=digit}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{General_Category=digit}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{General_Category=digit}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{General_Category=digit}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{General_Category=digit}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{General_Category=digit}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "digit",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{General_Category=punct}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{General_Category=punct}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{General_Category=punct}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{General_Category=punct}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{General_Category=punct}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{General_Category=punct}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "punct",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Gr_Base}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{Gr_Base}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{Gr_Base}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{Gr_Base}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{Gr_Base}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{Gr_Base}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Gr_Base",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Gr_Ext}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{Gr_Ext}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{Gr_Ext}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{Gr_Ext}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{Gr_Ext}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{Gr_Ext}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Gr_Ext",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Grapheme_Base}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Grapheme_Base}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Grapheme_Base}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Grapheme_Base}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Grapheme_Base}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Grapheme_Base}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Grapheme_Base",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Grapheme_Extend}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Grapheme_Extend}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Grapheme_Extend}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Grapheme_Extend}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Grapheme_Extend}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Grapheme_Extend}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Grapheme_Extend",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Hex_Digit}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{Hex_Digit}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{Hex_Digit}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{Hex_Digit}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{Hex_Digit}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{Hex_Digit}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Hex_Digit",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Hex}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\P{Hex}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\P{Hex}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\P{Hex}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\P{Hex}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\P{Hex}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Hex",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{IDC}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\P{IDC}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\P{IDC}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\P{IDC}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\P{IDC}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\P{IDC}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "IDC",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{IDSB}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{IDSB}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{IDSB}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{IDSB}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{IDSB}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{IDSB}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "IDSB",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{IDST}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{IDST}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{IDST}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{IDST}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{IDST}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{IDST}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "IDST",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{IDS_Binary_Operator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{IDS_Binary_Operator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{IDS_Binary_Operator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{IDS_Binary_Operator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{IDS_Binary_Operator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{IDS_Binary_Operator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "IDS_Binary_Operator",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{IDS_Trinary_Operator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{IDS_Trinary_Operator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{IDS_Trinary_Operator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{IDS_Trinary_Operator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{IDS_Trinary_Operator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{IDS_Trinary_Operator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "IDS_Trinary_Operator",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{IDS}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\P{IDS}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\P{IDS}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\P{IDS}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\P{IDS}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\P{IDS}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "IDS",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{ID_Continue}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{ID_Continue}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{ID_Continue}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{ID_Continue}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{ID_Continue}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{ID_Continue}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "ID_Continue",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{ID_Start}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{ID_Start}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{ID_Start}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{ID_Start}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{ID_Start}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{ID_Start}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "ID_Start",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Ideographic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Ideographic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Ideographic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Ideographic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Ideographic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Ideographic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Ideographic",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Ideo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{Ideo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{Ideo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{Ideo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{Ideo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{Ideo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Ideo",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Initial_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{Initial_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{Initial_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{Initial_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{Initial_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{Initial_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Initial_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Join_Control}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Join_Control}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Join_Control}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Join_Control}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Join_Control}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Join_Control}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Join_Control",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Join_C}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{Join_C}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{Join_C}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{Join_C}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{Join_C}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{Join_C}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Join_C",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{LC}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{LC}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{LC}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{LC}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{LC}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{LC}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "LC",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{LOE}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\P{LOE}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\P{LOE}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\P{LOE}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\P{LOE}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\P{LOE}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "LOE",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Letter_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Letter_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Letter_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Letter_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Letter_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Letter_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Letter_Number",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Line_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Line_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Line_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Line_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Line_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Line_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Line_Separator",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Ll}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Ll}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Ll}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Ll}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Ll}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Ll}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Ll",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Lm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Lm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Lm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Lm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Lm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Lm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Logical_Order_Exception}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Logical_Order_Exception}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Logical_Order_Exception}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Logical_Order_Exception}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Logical_Order_Exception}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Logical_Order_Exception}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Logical_Order_Exception",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Lowercase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Lowercase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Lowercase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Lowercase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Lowercase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Lowercase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lowercase_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Lowercase}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{Lowercase}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{Lowercase}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{Lowercase}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{Lowercase}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{Lowercase}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Lowercase",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Lower}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{Lower}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{Lower}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{Lower}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{Lower}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{Lower}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Lower",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Lo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Lo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Lo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Lo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Lo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Lo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Lt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Lt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Lt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Lt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Lt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Lt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Lu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Lu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Lu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Lu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Lu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Lu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{L}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\P{L}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\P{L}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\P{L}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\P{L}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\P{L}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "L",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Math_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Math_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Math_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Math_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Math_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Math_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Math_Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Math}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{Math}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{Math}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{Math}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{Math}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{Math}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Math",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Mc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Mc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Mc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Mc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Mc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Mc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Mc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Me}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Me}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Me}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Me}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Me}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Me}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Me",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Mn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Mn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Mn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Mn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Mn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Mn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Mn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Modifier_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Modifier_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Modifier_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Modifier_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Modifier_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Modifier_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Modifier_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Modifier_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Modifier_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Modifier_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Modifier_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Modifier_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Modifier_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Modifier_Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{M}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\P{M}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\P{M}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\P{M}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\P{M}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\P{M}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "M",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{NChar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{NChar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{NChar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{NChar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{NChar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{NChar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "NChar",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Nd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Nd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Nd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Nd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Nd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Nd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Nd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Nl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Nl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Nl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Nl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Nl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Nl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Nl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Noncharacter_Code_Point}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Noncharacter_Code_Point}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Noncharacter_Code_Point}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Noncharacter_Code_Point}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Noncharacter_Code_Point}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Noncharacter_Code_Point}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Noncharacter_Code_Point",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Nonspacing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Nonspacing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Nonspacing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Nonspacing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Nonspacing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Nonspacing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Nonspacing_Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{No}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{No}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{No}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{No}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{No}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{No}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "No",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Number",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{N}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\P{N}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\P{N}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\P{N}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\P{N}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\P{N}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "N",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Open_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Open_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Open_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Open_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Open_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Open_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Open_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Other_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Other_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Other_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Other_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Other_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Other_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Other_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Other_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Other_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Other_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Other_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Other_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Number",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Other_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Other_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Other_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Other_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Other_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Other_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Other_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Other_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Other_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Other_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Other_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Other_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Other}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{Other}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{Other}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{Other}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{Other}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{Other}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Paragraph_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{Paragraph_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{Paragraph_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{Paragraph_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{Paragraph_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{Paragraph_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Paragraph_Separator",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Pat_Syn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{Pat_Syn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{Pat_Syn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{Pat_Syn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{Pat_Syn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{Pat_Syn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Pat_Syn",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Pat_WS}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{Pat_WS}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{Pat_WS}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{Pat_WS}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{Pat_WS}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{Pat_WS}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Pat_WS",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Pattern_Syntax}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Pattern_Syntax}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Pattern_Syntax}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Pattern_Syntax}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Pattern_Syntax}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Pattern_Syntax}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Pattern_Syntax",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Pattern_White_Space}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{Pattern_White_Space}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{Pattern_White_Space}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{Pattern_White_Space}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{Pattern_White_Space}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{Pattern_White_Space}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Pattern_White_Space",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Pc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Pc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Pc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Pc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Pc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Pc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Pd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Pd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Pd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Pd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Pd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Pd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Pe}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Pe}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Pe}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Pe}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Pe}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Pe}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pe",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Pf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Pf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Pf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Pf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Pf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Pf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pf",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Pi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Pi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Pi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Pi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Pi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Pi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Po}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Po}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Po}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Po}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Po}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Po}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Po",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Private_Use}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Private_Use}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Private_Use}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Private_Use}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Private_Use}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Private_Use}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Private_Use",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Ps}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Ps}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Ps}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Ps}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Ps}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Ps}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Ps",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{P}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\P{P}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\P{P}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\P{P}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\P{P}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\P{P}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "P",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{QMark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{QMark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{QMark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{QMark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{QMark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{QMark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "QMark",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Quotation_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Quotation_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Quotation_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Quotation_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Quotation_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Quotation_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Quotation_Mark",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{RI}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{RI}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{RI}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{RI}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{RI}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{RI}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "RI",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Radical}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{Radical}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{Radical}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{Radical}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{Radical}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{Radical}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Radical",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Regional_Indicator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{Regional_Indicator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{Regional_Indicator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{Regional_Indicator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{Regional_Indicator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{Regional_Indicator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Regional_Indicator",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{SD}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{SD}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{SD}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{SD}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{SD}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{SD}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "SD",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{STerm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{STerm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{STerm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{STerm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{STerm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{STerm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "STerm",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Adlam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Adlam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Adlam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Adlam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Adlam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Adlam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Adlam",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Adlm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Adlm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Adlm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Adlm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Adlm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Adlm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Adlm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Aghb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Aghb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Aghb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Aghb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Aghb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Aghb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Aghb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Ahom}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Ahom}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Ahom}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Ahom}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Ahom}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Ahom}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ahom",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Anatolian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Script=Anatolian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Script=Anatolian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Script=Anatolian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Script=Anatolian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Script=Anatolian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Anatolian_Hieroglyphs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Arabic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Arabic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Arabic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Arabic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Arabic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Arabic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Arabic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Arab}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Arab}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Arab}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Arab}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Arab}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Arab}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Arab",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Armenian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Armenian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Armenian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Armenian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Armenian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Armenian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Armenian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Armi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Armi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Armi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Armi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Armi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Armi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Armi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Armn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Armn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Armn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Armn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Armn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Armn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Armn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Avestan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Avestan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Avestan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Avestan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Avestan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Avestan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Avestan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Avst}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Avst}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Avst}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Avst}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Avst}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Avst}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Avst",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Balinese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Balinese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Balinese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Balinese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Balinese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Balinese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Balinese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Bali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Bali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Bali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Bali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Bali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Bali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bali",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Bamum}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Bamum}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Bamum}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Bamum}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Bamum}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Bamum}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bamum",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Bamu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Bamu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Bamu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Bamu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Bamu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Bamu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bamu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Bassa_Vah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Script=Bassa_Vah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Script=Bassa_Vah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Script=Bassa_Vah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Script=Bassa_Vah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Script=Bassa_Vah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bassa_Vah",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Bass}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Bass}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Bass}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Bass}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Bass}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Bass}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bass",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Batak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Batak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Batak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Batak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Batak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Batak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Batak",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Batk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Batk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Batk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Batk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Batk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Batk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Batk",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Bengali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Bengali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Bengali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Bengali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Bengali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Bengali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bengali",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Beng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Beng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Beng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Beng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Beng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Beng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Beng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Bhaiksuki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Script=Bhaiksuki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Script=Bhaiksuki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Script=Bhaiksuki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Script=Bhaiksuki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Script=Bhaiksuki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bhaiksuki",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Bhks}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Bhks}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Bhks}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Bhks}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Bhks}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Bhks}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bhks",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Bopomofo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Bopomofo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Bopomofo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Bopomofo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Bopomofo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Bopomofo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bopomofo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Bopo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Bopo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Bopo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Bopo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Bopo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Bopo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bopo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Brahmi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Brahmi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Brahmi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Brahmi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Brahmi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Brahmi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Brahmi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Brah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Brah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Brah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Brah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Brah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Brah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Brah",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Braille}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Braille}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Braille}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Braille}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Braille}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Braille}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Braille",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Brai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Brai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Brai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Brai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Brai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Brai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Brai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Buginese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Buginese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Buginese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Buginese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Buginese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Buginese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Buginese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Bugi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Bugi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Bugi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Bugi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Bugi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Bugi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bugi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Buhd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Buhd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Buhd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Buhd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Buhd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Buhd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Buhd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Buhid}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Buhid}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Buhid}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Buhid}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Buhid}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Buhid}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Buhid",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Cakm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Cakm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Cakm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Cakm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Cakm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Cakm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cakm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Canadian_Aboriginal}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script=Canadian_Aboriginal}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script=Canadian_Aboriginal}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script=Canadian_Aboriginal}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script=Canadian_Aboriginal}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script=Canadian_Aboriginal}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Canadian_Aboriginal",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Cans}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Cans}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Cans}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Cans}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Cans}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Cans}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cans",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Carian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Carian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Carian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Carian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Carian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Carian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Carian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Cari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Cari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Cari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Cari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Cari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Cari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Caucasian_Albanian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script=Caucasian_Albanian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script=Caucasian_Albanian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script=Caucasian_Albanian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script=Caucasian_Albanian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script=Caucasian_Albanian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Caucasian_Albanian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Chakma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Chakma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Chakma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Chakma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Chakma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Chakma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Chakma",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Cham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Cham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Cham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Cham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Cham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Cham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Cherokee}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Cherokee}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Cherokee}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Cherokee}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Cherokee}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Cherokee}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cherokee",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Cher}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Cher}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Cher}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Cher}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Cher}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Cher}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cher",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Chorasmian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Script=Chorasmian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Script=Chorasmian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Script=Chorasmian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Script=Chorasmian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Script=Chorasmian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Chorasmian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Chrs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Chrs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Chrs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Chrs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Chrs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Chrs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Chrs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Common}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Common}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Common}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Common}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Common}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Common}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Common",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Coptic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Coptic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Coptic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Coptic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Coptic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Coptic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Coptic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Copt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Copt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Copt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Copt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Copt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Copt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Copt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Cpmn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Cpmn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Cpmn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Cpmn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Cpmn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Cpmn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cpmn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Cprt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Cprt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Cprt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Cprt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Cprt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Cprt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cprt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Cuneiform}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Script=Cuneiform}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Script=Cuneiform}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Script=Cuneiform}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Script=Cuneiform}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Script=Cuneiform}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cuneiform",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Cypriot}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Cypriot}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Cypriot}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Cypriot}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Cypriot}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Cypriot}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cypriot",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Cypro_Minoan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{Script=Cypro_Minoan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{Script=Cypro_Minoan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{Script=Cypro_Minoan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{Script=Cypro_Minoan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{Script=Cypro_Minoan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cypro_Minoan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Cyrillic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Cyrillic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Cyrillic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Cyrillic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Cyrillic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Cyrillic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cyrillic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Cyrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Cyrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Cyrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Cyrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Cyrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Cyrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cyrl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Deseret}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Deseret}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Deseret}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Deseret}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Deseret}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Deseret}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Deseret",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Devanagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Script=Devanagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Script=Devanagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Script=Devanagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Script=Devanagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Script=Devanagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Devanagari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Deva}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Deva}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Deva}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Deva}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Deva}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Deva}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Deva",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Diak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Diak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Diak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Diak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Diak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Diak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Diak",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Dives_Akuru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{Script=Dives_Akuru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{Script=Dives_Akuru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{Script=Dives_Akuru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{Script=Dives_Akuru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{Script=Dives_Akuru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Dives_Akuru",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Dogra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Dogra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Dogra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Dogra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Dogra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Dogra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Dogra",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Dogr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Dogr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Dogr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Dogr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Dogr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Dogr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Dogr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Dsrt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Dsrt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Dsrt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Dsrt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Dsrt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Dsrt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Dsrt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Duployan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Duployan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Duployan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Duployan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Duployan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Duployan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Duployan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Dupl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Dupl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Dupl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Dupl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Dupl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Dupl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Dupl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Egyptian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{Script=Egyptian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{Script=Egyptian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{Script=Egyptian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{Script=Egyptian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{Script=Egyptian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Egyptian_Hieroglyphs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Egyp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Egyp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Egyp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Egyp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Egyp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Egyp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Egyp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Elbasan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Elbasan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Elbasan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Elbasan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Elbasan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Elbasan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Elbasan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Elba}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Elba}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Elba}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Elba}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Elba}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Elba}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Elba",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Elymaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Elymaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Elymaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Elymaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Elymaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Elymaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Elymaic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Elym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Elym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Elym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Elym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Elym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Elym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Elym",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Ethiopic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Ethiopic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Ethiopic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Ethiopic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Ethiopic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Ethiopic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ethiopic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Ethi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Ethi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Ethi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Ethi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Ethi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Ethi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ethi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Georgian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Georgian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Georgian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Georgian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Georgian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Georgian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Georgian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Geor}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Geor}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Geor}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Geor}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Geor}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Geor}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Geor",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Glagolitic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Script=Glagolitic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Script=Glagolitic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Script=Glagolitic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Script=Glagolitic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Script=Glagolitic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Glagolitic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Glag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Glag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Glag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Glag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Glag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Glag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Glag",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Gong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Gong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Gong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Gong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Gong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Gong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Gonm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Gonm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Gonm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Gonm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Gonm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Gonm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gonm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Gothic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Gothic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Gothic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Gothic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Gothic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Gothic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gothic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Goth}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Goth}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Goth}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Goth}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Goth}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Goth}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Goth",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Grantha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Grantha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Grantha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Grantha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Grantha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Grantha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Grantha",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Gran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Gran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Gran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Gran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Gran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Gran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gran",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Greek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Greek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Greek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Greek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Greek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Greek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Greek",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Grek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Grek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Grek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Grek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Grek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Grek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Grek",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Gujarati}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Gujarati}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Gujarati}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Gujarati}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Gujarati}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Gujarati}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gujarati",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Gujr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Gujr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Gujr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Gujr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Gujr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Gujr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gujr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Gunjala_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{Script=Gunjala_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{Script=Gunjala_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{Script=Gunjala_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{Script=Gunjala_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{Script=Gunjala_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gunjala_Gondi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Gurmukhi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Gurmukhi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Gurmukhi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Gurmukhi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Gurmukhi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Gurmukhi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gurmukhi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Guru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Guru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Guru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Guru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Guru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Guru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Guru",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hangul}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Hangul}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Hangul}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Hangul}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Hangul}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Hangul}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hangul",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Hang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Hang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Hang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Hang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Hang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hang",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hanifi_Rohingya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script=Hanifi_Rohingya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script=Hanifi_Rohingya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script=Hanifi_Rohingya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script=Hanifi_Rohingya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script=Hanifi_Rohingya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hanifi_Rohingya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Hani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Hani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Hani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Hani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Hani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hano}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Hano}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Hano}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Hano}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Hano}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Hano}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hano",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hanunoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Hanunoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Hanunoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Hanunoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Hanunoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Hanunoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hanunoo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Han}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{Script=Han}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{Script=Han}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{Script=Han}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{Script=Han}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{Script=Han}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Han",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hatran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Hatran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Hatran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Hatran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Hatran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Hatran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hatran",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hatr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Hatr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Hatr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Hatr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Hatr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Hatr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hatr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hebrew}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Hebrew}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Hebrew}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Hebrew}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Hebrew}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Hebrew}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hebrew",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hebr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Hebr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Hebr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Hebr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Hebr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Hebr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hebr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hiragana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Hiragana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Hiragana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Hiragana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Hiragana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Hiragana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hiragana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hira}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Hira}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Hira}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Hira}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Hira}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Hira}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hira",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hluw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Hluw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Hluw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Hluw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Hluw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Hluw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hluw",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hmng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Hmng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Hmng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Hmng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Hmng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Hmng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hmng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hmnp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Hmnp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Hmnp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Hmnp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Hmnp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Hmnp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hmnp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Hung}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Hung}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Hung}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Hung}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Hung}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Hung}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hung",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Imperial_Aramaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script=Imperial_Aramaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script=Imperial_Aramaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script=Imperial_Aramaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script=Imperial_Aramaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script=Imperial_Aramaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Imperial_Aramaic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Inherited}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Script=Inherited}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Script=Inherited}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Script=Inherited}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Script=Inherited}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Script=Inherited}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Inherited",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Inscriptional_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Script=Inscriptional_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Script=Inscriptional_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Script=Inscriptional_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Script=Inscriptional_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Script=Inscriptional_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Inscriptional_Pahlavi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Inscriptional_Parthian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{Script=Inscriptional_Parthian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{Script=Inscriptional_Parthian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{Script=Inscriptional_Parthian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{Script=Inscriptional_Parthian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{Script=Inscriptional_Parthian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Inscriptional_Parthian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Ital}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Ital}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Ital}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Ital}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Ital}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Ital}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ital",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Javanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Javanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Javanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Javanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Javanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Javanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Javanese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Java}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Java}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Java}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Java}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Java}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Java}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Java",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Kaithi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Kaithi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Kaithi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Kaithi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Kaithi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Kaithi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kaithi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Kali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Kali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Kali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Kali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Kali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Kali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kali",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Kana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Kana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Kana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Kana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Kana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Kana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Kannada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Kannada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Kannada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Kannada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Kannada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Kannada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kannada",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Katakana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Katakana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Katakana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Katakana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Katakana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Katakana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Katakana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Kawi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Kawi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Kawi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Kawi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Kawi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Kawi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kawi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Kayah_Li}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Kayah_Li}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Kayah_Li}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Kayah_Li}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Kayah_Li}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Kayah_Li}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kayah_Li",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Kharoshthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Script=Kharoshthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Script=Kharoshthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Script=Kharoshthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Script=Kharoshthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Script=Kharoshthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kharoshthi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Khar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Khar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Khar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Khar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Khar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Khar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Khitan_Small_Script}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script=Khitan_Small_Script}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script=Khitan_Small_Script}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script=Khitan_Small_Script}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script=Khitan_Small_Script}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script=Khitan_Small_Script}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khitan_Small_Script",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Khmer}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Khmer}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Khmer}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Khmer}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Khmer}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Khmer}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khmer",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Khmr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Khmr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Khmr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Khmr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Khmr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Khmr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khmr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Khojki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Khojki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Khojki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Khojki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Khojki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Khojki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khojki",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Khoj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Khoj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Khoj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Khoj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Khoj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Khoj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khoj",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Khudawadi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Script=Khudawadi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Script=Khudawadi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Script=Khudawadi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Script=Khudawadi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Script=Khudawadi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khudawadi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Kits}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Kits}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Kits}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Kits}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Kits}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Kits}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kits",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Knda}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Knda}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Knda}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Knda}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Knda}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Knda}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Knda",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Kthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Kthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Kthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Kthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Kthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Kthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kthi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Lana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Lana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Lana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Lana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Lana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Lana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Laoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Laoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Laoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Laoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Laoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Laoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Laoo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Lao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{Script=Lao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{Script=Lao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{Script=Lao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{Script=Lao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{Script=Lao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lao",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Latin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Latin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Latin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Latin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Latin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Latin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Latin",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Latn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Latn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Latn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Latn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Latn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Latn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Latn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Lepcha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Lepcha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Lepcha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Lepcha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Lepcha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Lepcha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lepcha",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Lepc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Lepc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Lepc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Lepc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Lepc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Lepc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lepc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Limbu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Limbu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Limbu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Limbu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Limbu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Limbu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Limbu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Limb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Limb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Limb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Limb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Limb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Limb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Limb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Lina}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Lina}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Lina}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Lina}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Lina}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Lina}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lina",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Linb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Linb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Linb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Linb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Linb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Linb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Linb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Linear_A}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Linear_A}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Linear_A}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Linear_A}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Linear_A}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Linear_A}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Linear_A",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Linear_B}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Linear_B}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Linear_B}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Linear_B}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Linear_B}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Linear_B}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Linear_B",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Lisu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Lisu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Lisu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Lisu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Lisu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Lisu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lisu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Lycian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Lycian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Lycian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Lycian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Lycian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Lycian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lycian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Lyci}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Lyci}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Lyci}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Lyci}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Lyci}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Lyci}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lyci",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Lydian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Lydian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Lydian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Lydian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Lydian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Lydian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lydian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Lydi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Lydi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Lydi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Lydi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Lydi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Lydi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lydi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mahajani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Mahajani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Mahajani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Mahajani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Mahajani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Mahajani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mahajani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mahj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Mahj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Mahj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Mahj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Mahj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Mahj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mahj",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Makasar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Makasar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Makasar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Makasar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Makasar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Makasar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Makasar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Maka}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Maka}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Maka}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Maka}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Maka}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Maka}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Maka",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Malayalam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Script=Malayalam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Script=Malayalam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Script=Malayalam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Script=Malayalam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Script=Malayalam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Malayalam",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mandaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Mandaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Mandaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Mandaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Mandaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Mandaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mandaic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Mand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Mand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Mand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Mand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Mand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mand",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Manichaean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Script=Manichaean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Script=Manichaean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Script=Manichaean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Script=Manichaean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Script=Manichaean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Manichaean",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Mani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Mani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Mani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Mani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Mani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Marchen}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Marchen}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Marchen}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Marchen}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Marchen}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Marchen}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Marchen",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Marc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Marc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Marc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Marc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Marc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Marc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Marc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Masaram_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{Script=Masaram_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{Script=Masaram_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{Script=Masaram_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{Script=Masaram_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{Script=Masaram_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Masaram_Gondi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Medefaidrin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{Script=Medefaidrin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{Script=Medefaidrin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{Script=Medefaidrin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{Script=Medefaidrin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{Script=Medefaidrin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Medefaidrin",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Medf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Medf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Medf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Medf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Medf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Medf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Medf",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Meetei_Mayek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{Script=Meetei_Mayek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{Script=Meetei_Mayek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{Script=Meetei_Mayek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{Script=Meetei_Mayek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{Script=Meetei_Mayek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Meetei_Mayek",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mende_Kikakui}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{Script=Mende_Kikakui}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{Script=Mende_Kikakui}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{Script=Mende_Kikakui}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{Script=Mende_Kikakui}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{Script=Mende_Kikakui}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mende_Kikakui",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mend}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Mend}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Mend}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Mend}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Mend}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Mend}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mend",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Merc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Merc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Merc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Merc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Merc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Merc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Merc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Meroitic_Cursive}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script=Meroitic_Cursive}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script=Meroitic_Cursive}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script=Meroitic_Cursive}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script=Meroitic_Cursive}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script=Meroitic_Cursive}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Meroitic_Cursive",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Meroitic_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{Script=Meroitic_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{Script=Meroitic_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{Script=Meroitic_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{Script=Meroitic_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{Script=Meroitic_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Meroitic_Hieroglyphs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mero}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Mero}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Mero}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Mero}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Mero}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Mero}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mero",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Miao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Miao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Miao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Miao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Miao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Miao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Miao",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mlym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Mlym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Mlym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Mlym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Mlym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Mlym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mlym",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Modi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Modi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Modi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Modi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Modi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Modi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Modi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mongolian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Script=Mongolian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Script=Mongolian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Script=Mongolian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Script=Mongolian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Script=Mongolian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mongolian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Mong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Mong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Mong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Mong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Mong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mroo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Mroo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Mroo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Mroo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Mroo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Mroo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mroo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mro}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{Script=Mro}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{Script=Mro}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{Script=Mro}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{Script=Mro}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{Script=Mro}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mro",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mtei}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Mtei}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Mtei}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Mtei}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Mtei}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Mtei}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mtei",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Multani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Multani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Multani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Multani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Multani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Multani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Multani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mult}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Mult}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Mult}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Mult}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Mult}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Mult}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mult",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Myanmar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Myanmar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Myanmar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Myanmar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Myanmar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Myanmar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Myanmar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Mymr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Mymr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Mymr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Mymr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Mymr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Mymr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mymr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Nabataean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Script=Nabataean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Script=Nabataean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Script=Nabataean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Script=Nabataean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Script=Nabataean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nabataean",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Nag_Mundari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{Script=Nag_Mundari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{Script=Nag_Mundari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{Script=Nag_Mundari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{Script=Nag_Mundari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{Script=Nag_Mundari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nag_Mundari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Nagm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Nagm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Nagm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Nagm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Nagm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Nagm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nagm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Nandinagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{Script=Nandinagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{Script=Nandinagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{Script=Nandinagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{Script=Nandinagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{Script=Nandinagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nandinagari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Nand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Nand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Nand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Nand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Nand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Nand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nand",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Narb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Narb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Narb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Narb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Narb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Narb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Narb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Nbat}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Nbat}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Nbat}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Nbat}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Nbat}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Nbat}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nbat",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=New_Tai_Lue}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{Script=New_Tai_Lue}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{Script=New_Tai_Lue}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{Script=New_Tai_Lue}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{Script=New_Tai_Lue}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{Script=New_Tai_Lue}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "New_Tai_Lue",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Newa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Newa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Newa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Newa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Newa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Newa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Newa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Nkoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Nkoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Nkoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Nkoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Nkoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Nkoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nkoo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Nko}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{Script=Nko}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{Script=Nko}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{Script=Nko}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{Script=Nko}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{Script=Nko}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nko",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Nshu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Nshu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Nshu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Nshu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Nshu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Nshu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nshu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Nushu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Nushu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Nushu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Nushu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Nushu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Nushu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nushu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Nyiakeng_Puachue_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{Script=Nyiakeng_Puachue_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{Script=Nyiakeng_Puachue_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{Script=Nyiakeng_Puachue_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{Script=Nyiakeng_Puachue_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{Script=Nyiakeng_Puachue_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nyiakeng_Puachue_Hmong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Ogam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Ogam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Ogam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Ogam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Ogam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Ogam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ogam",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Ogham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Ogham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Ogham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Ogham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Ogham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Ogham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ogham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Ol_Chiki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Ol_Chiki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Ol_Chiki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Ol_Chiki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Ol_Chiki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Ol_Chiki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ol_Chiki",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Olck}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Olck}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Olck}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Olck}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Olck}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Olck}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Olck",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Old_Hungarian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{Script=Old_Hungarian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{Script=Old_Hungarian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{Script=Old_Hungarian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{Script=Old_Hungarian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{Script=Old_Hungarian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Hungarian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Old_Italic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Script=Old_Italic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Script=Old_Italic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Script=Old_Italic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Script=Old_Italic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Script=Old_Italic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Italic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Old_North_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script=Old_North_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script=Old_North_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script=Old_North_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script=Old_North_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script=Old_North_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_North_Arabian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Old_Permic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Script=Old_Permic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Script=Old_Permic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Script=Old_Permic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Script=Old_Permic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Script=Old_Permic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Permic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Old_Persian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{Script=Old_Persian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{Script=Old_Persian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{Script=Old_Persian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{Script=Old_Persian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{Script=Old_Persian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Persian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Old_Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{Script=Old_Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{Script=Old_Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{Script=Old_Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{Script=Old_Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{Script=Old_Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Sogdian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Old_South_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script=Old_South_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script=Old_South_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script=Old_South_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script=Old_South_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script=Old_South_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_South_Arabian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Old_Turkic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Script=Old_Turkic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Script=Old_Turkic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Script=Old_Turkic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Script=Old_Turkic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Script=Old_Turkic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Turkic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Old_Uyghur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Script=Old_Uyghur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Script=Old_Uyghur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Script=Old_Uyghur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Script=Old_Uyghur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Script=Old_Uyghur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Uyghur",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Oriya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Oriya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Oriya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Oriya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Oriya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Oriya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Oriya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Orkh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Orkh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Orkh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Orkh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Orkh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Orkh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Orkh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Orya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Orya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Orya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Orya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Orya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Orya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Orya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Osage}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Osage}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Osage}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Osage}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Osage}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Osage}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Osage",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Osge}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Osge}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Osge}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Osge}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Osge}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Osge}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Osge",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Osmanya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Osmanya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Osmanya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Osmanya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Osmanya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Osmanya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Osmanya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Osma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Osma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Osma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Osma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Osma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Osma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Osma",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Ougr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Ougr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Ougr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Ougr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Ougr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Ougr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ougr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Pahawh_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{Script=Pahawh_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{Script=Pahawh_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{Script=Pahawh_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{Script=Pahawh_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{Script=Pahawh_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Pahawh_Hmong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Palmyrene}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Script=Palmyrene}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Script=Palmyrene}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Script=Palmyrene}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Script=Palmyrene}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Script=Palmyrene}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Palmyrene",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Palm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Palm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Palm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Palm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Palm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Palm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Palm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Pau_Cin_Hau}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{Script=Pau_Cin_Hau}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{Script=Pau_Cin_Hau}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{Script=Pau_Cin_Hau}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{Script=Pau_Cin_Hau}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{Script=Pau_Cin_Hau}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Pau_Cin_Hau",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Pauc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Pauc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Pauc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Pauc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Pauc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Pauc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Pauc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Perm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Perm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Perm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Perm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Perm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Perm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Perm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Phags_Pa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Phags_Pa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Phags_Pa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Phags_Pa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Phags_Pa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Phags_Pa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Phags_Pa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Phag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Phag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Phag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Phag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Phag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Phag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Phag",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Phli}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Phli}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Phli}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Phli}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Phli}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Phli}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Phli",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Phlp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Phlp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Phlp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Phlp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Phlp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Phlp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Phlp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Phnx}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Phnx}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Phnx}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Phnx}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Phnx}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Phnx}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Phnx",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Phoenician}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Script=Phoenician}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Script=Phoenician}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Script=Phoenician}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Script=Phoenician}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Script=Phoenician}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Phoenician",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Plrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Plrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Plrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Plrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Plrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Plrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Plrd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Prti}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Prti}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Prti}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Prti}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Prti}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Prti}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Prti",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Psalter_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script=Psalter_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script=Psalter_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script=Psalter_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script=Psalter_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script=Psalter_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Psalter_Pahlavi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Qaac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Qaac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Qaac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Qaac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Qaac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Qaac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Qaac",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Qaai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Qaai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Qaai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Qaai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Qaai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Qaai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Qaai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Rejang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Rejang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Rejang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Rejang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Rejang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Rejang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Rejang",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Rjng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Rjng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Rjng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Rjng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Rjng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Rjng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Rjng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Rohg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Rohg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Rohg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Rohg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Rohg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Rohg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Rohg",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Runic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Runic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Runic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Runic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Runic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Runic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Runic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Runr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Runr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Runr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Runr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Runr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Runr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Runr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Samaritan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Script=Samaritan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Script=Samaritan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Script=Samaritan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Script=Samaritan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Script=Samaritan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Samaritan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Samr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Samr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Samr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Samr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Samr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Samr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Samr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sarb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Sarb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Sarb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Sarb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Sarb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Sarb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sarb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Saurashtra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Script=Saurashtra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Script=Saurashtra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Script=Saurashtra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Script=Saurashtra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Script=Saurashtra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Saurashtra",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Saur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Saur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Saur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Saur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Saur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Saur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Saur",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sgnw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Sgnw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Sgnw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Sgnw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Sgnw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Sgnw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sgnw",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sharada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Sharada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Sharada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Sharada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Sharada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Sharada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sharada",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Shavian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Shavian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Shavian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Shavian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Shavian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Shavian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Shavian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Shaw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Shaw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Shaw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Shaw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Shaw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Shaw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Shaw",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Shrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Shrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Shrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Shrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Shrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Shrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Shrd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Siddham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Siddham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Siddham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Siddham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Siddham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Siddham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Siddham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sidd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Sidd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Sidd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Sidd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Sidd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Sidd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sidd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=SignWriting}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{Script=SignWriting}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{Script=SignWriting}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{Script=SignWriting}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{Script=SignWriting}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{Script=SignWriting}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "SignWriting",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sind}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Sind}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Sind}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Sind}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Sind}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Sind}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sind",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sinhala}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Sinhala}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Sinhala}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Sinhala}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Sinhala}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Sinhala}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sinhala",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Sinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Sinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Sinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Sinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Sinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sinh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sogdian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sogd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Sogd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Sogd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Sogd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Sogd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Sogd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sogd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sogo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Sogo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Sogo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Sogo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Sogo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Sogo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sogo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sora_Sompeng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{Script=Sora_Sompeng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{Script=Sora_Sompeng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{Script=Sora_Sompeng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{Script=Sora_Sompeng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{Script=Sora_Sompeng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sora_Sompeng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sora}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Sora}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Sora}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Sora}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Sora}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Sora}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sora",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Soyombo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Soyombo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Soyombo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Soyombo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Soyombo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Soyombo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Soyombo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Soyo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Soyo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Soyo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Soyo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Soyo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Soyo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Soyo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sundanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Script=Sundanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Script=Sundanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Script=Sundanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Script=Sundanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Script=Sundanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sundanese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sund}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Sund}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Sund}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Sund}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Sund}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Sund}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sund",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Syloti_Nagri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{Script=Syloti_Nagri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{Script=Syloti_Nagri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{Script=Syloti_Nagri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{Script=Syloti_Nagri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{Script=Syloti_Nagri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Syloti_Nagri",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Sylo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Sylo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Sylo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Sylo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Sylo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Sylo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sylo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Syrc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Syrc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Syrc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Syrc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Syrc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Syrc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Syrc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Syriac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Syriac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Syriac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Syriac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Syriac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Syriac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Syriac",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tagalog}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Tagalog}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Tagalog}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Tagalog}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Tagalog}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Tagalog}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tagalog",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tagbanwa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Tagbanwa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Tagbanwa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Tagbanwa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Tagbanwa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Tagbanwa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tagbanwa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tagb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Tagb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Tagb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Tagb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Tagb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Tagb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tagb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tai_Le}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Tai_Le}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Tai_Le}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Tai_Le}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Tai_Le}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Tai_Le}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tai_Le",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tai_Tham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Tai_Tham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Tai_Tham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Tai_Tham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Tai_Tham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Tai_Tham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tai_Tham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tai_Viet}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Tai_Viet}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Tai_Viet}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Tai_Viet}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Tai_Viet}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Tai_Viet}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tai_Viet",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Takri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Takri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Takri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Takri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Takri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Takri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Takri",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Takr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Takr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Takr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Takr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Takr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Takr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Takr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tale}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Tale}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Tale}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Tale}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Tale}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Tale}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tale",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Talu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Talu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Talu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Talu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Talu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Talu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Talu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tamil}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Script=Tamil}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Script=Tamil}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Script=Tamil}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Script=Tamil}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Script=Tamil}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tamil",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Taml}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Taml}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Taml}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Taml}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Taml}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Taml}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Taml",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tangsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Tangsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Tangsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Tangsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Tangsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Tangsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tangsa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tangut}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Tangut}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Tangut}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Tangut}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Tangut}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Tangut}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tangut",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Tang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Tang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Tang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Tang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Tang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tang",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tavt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Tavt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Tavt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Tavt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Tavt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Tavt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tavt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Telugu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Telugu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Telugu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Telugu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Telugu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Telugu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Telugu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Telu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Telu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Telu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Telu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Telu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Telu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Telu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tfng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Tfng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Tfng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Tfng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Tfng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Tfng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tfng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tglg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Tglg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Tglg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Tglg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Tglg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Tglg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tglg",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Thaana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Thaana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Thaana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Thaana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Thaana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Thaana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Thaana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Thaa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Thaa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Thaa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Thaa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Thaa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Thaa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Thaa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Thai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Thai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Thai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Thai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Thai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Thai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Thai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tibetan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Tibetan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Tibetan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Tibetan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Tibetan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Tibetan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tibetan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tibt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Tibt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Tibt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Tibt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Tibt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Tibt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tibt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tifinagh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Tifinagh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Tifinagh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Tifinagh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Tifinagh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Tifinagh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tifinagh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tirhuta}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{Script=Tirhuta}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{Script=Tirhuta}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{Script=Tirhuta}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{Script=Tirhuta}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{Script=Tirhuta}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tirhuta",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tirh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Tirh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Tirh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Tirh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Tirh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Tirh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tirh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Tnsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Tnsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Tnsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Tnsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Tnsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Tnsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tnsa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Toto}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Toto}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Toto}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Toto}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Toto}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Toto}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Toto",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Ugaritic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Ugaritic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Ugaritic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Ugaritic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Ugaritic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Ugaritic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ugaritic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Ugar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Ugar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Ugar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Ugar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Ugar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Ugar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ugar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Vaii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Vaii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Vaii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Vaii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Vaii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Vaii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Vaii",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Vai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{Script=Vai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{Script=Vai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{Script=Vai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{Script=Vai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{Script=Vai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Vai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Vithkuqi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Script=Vithkuqi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Script=Vithkuqi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Script=Vithkuqi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Script=Vithkuqi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Script=Vithkuqi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Vithkuqi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Vith}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Vith}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Vith}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Vith}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Vith}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Vith}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Vith",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Wancho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Wancho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Wancho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Wancho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Wancho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Wancho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Wancho",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Warang_Citi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{Script=Warang_Citi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{Script=Warang_Citi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{Script=Warang_Citi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{Script=Warang_Citi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{Script=Warang_Citi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Warang_Citi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Wara}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Wara}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Wara}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Wara}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Wara}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Wara}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Wara",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Wcho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Wcho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Wcho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Wcho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Wcho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Wcho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Wcho",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Xpeo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Xpeo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Xpeo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Xpeo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Xpeo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Xpeo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Xpeo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Xsux}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Xsux}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Xsux}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Xsux}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Xsux}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Xsux}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Xsux",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Yezidi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{Script=Yezidi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{Script=Yezidi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{Script=Yezidi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{Script=Yezidi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{Script=Yezidi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Yezidi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Yezi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Yezi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Yezi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Yezi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Yezi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Yezi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Yezi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Yiii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Yiii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Yiii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Yiii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Yiii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Yiii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Yiii",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Yi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{Script=Yi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{Script=Yi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{Script=Yi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{Script=Yi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{Script=Yi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Yi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Zanabazar_Square}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script=Zanabazar_Square}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script=Zanabazar_Square}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script=Zanabazar_Square}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script=Zanabazar_Square}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script=Zanabazar_Square}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Zanabazar_Square",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Zanb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Zanb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Zanb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Zanb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Zanb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Zanb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Zanb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Zinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Zinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Zinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Zinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Zinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Zinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Zinh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script=Zyyy}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Script=Zyyy}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Script=Zyyy}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Script=Zyyy}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Script=Zyyy}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Script=Zyyy}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Zyyy",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Adlam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Adlam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Adlam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Adlam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Adlam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Adlam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Adlam",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Adlm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Adlm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Adlm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Adlm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Adlm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Adlm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Adlm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Aghb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Aghb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Aghb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Aghb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Aghb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Aghb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Aghb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Ahom}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Ahom}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Ahom}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Ahom}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Ahom}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Ahom}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ahom",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Anatolian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 49,
+        "raw": "/^\\P{Script_Extensions=Anatolian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 47,
+          "raw": "^\\P{Script_Extensions=Anatolian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 47,
+              "raw": "^\\P{Script_Extensions=Anatolian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 46,
+                  "raw": "\\P{Script_Extensions=Anatolian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 45,
+                    "raw": "\\P{Script_Extensions=Anatolian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Anatolian_Hieroglyphs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 46,
+                  "end": 47,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 48,
+          "end": 49,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Arabic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Arabic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Arabic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Arabic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Arabic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Arabic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Arabic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Arab}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Arab}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Arab}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Arab}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Arab}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Arab}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Arab",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Armenian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Armenian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Armenian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Armenian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Armenian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Armenian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Armenian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Armi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Armi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Armi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Armi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Armi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Armi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Armi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Armn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Armn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Armn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Armn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Armn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Armn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Armn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Avestan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Avestan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Avestan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Avestan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Avestan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Avestan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Avestan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Avst}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Avst}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Avst}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Avst}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Avst}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Avst}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Avst",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Balinese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Balinese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Balinese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Balinese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Balinese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Balinese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Balinese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Bali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Bali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Bali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Bali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Bali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Bali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bali",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Bamum}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Bamum}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Bamum}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Bamum}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Bamum}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Bamum}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bamum",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Bamu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Bamu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Bamu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Bamu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Bamu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Bamu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bamu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Bassa_Vah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{Script_Extensions=Bassa_Vah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{Script_Extensions=Bassa_Vah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{Script_Extensions=Bassa_Vah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{Script_Extensions=Bassa_Vah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{Script_Extensions=Bassa_Vah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bassa_Vah",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Bass}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Bass}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Bass}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Bass}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Bass}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Bass}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bass",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Batak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Batak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Batak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Batak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Batak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Batak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Batak",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Batk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Batk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Batk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Batk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Batk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Batk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Batk",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Bengali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Bengali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Bengali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Bengali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Bengali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Bengali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bengali",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Beng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Beng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Beng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Beng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Beng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Beng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Beng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Bhaiksuki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{Script_Extensions=Bhaiksuki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{Script_Extensions=Bhaiksuki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{Script_Extensions=Bhaiksuki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{Script_Extensions=Bhaiksuki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{Script_Extensions=Bhaiksuki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bhaiksuki",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Bhks}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Bhks}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Bhks}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Bhks}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Bhks}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Bhks}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bhks",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Bopomofo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Bopomofo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Bopomofo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Bopomofo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Bopomofo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Bopomofo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bopomofo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Bopo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Bopo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Bopo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Bopo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Bopo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Bopo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bopo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Brahmi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Brahmi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Brahmi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Brahmi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Brahmi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Brahmi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Brahmi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Brah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Brah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Brah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Brah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Brah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Brah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Brah",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Braille}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Braille}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Braille}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Braille}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Braille}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Braille}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Braille",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Brai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Brai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Brai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Brai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Brai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Brai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Brai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Buginese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Buginese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Buginese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Buginese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Buginese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Buginese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Buginese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Bugi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Bugi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Bugi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Bugi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Bugi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Bugi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bugi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Buhd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Buhd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Buhd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Buhd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Buhd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Buhd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Buhd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Buhid}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Buhid}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Buhid}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Buhid}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Buhid}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Buhid}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Buhid",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Cakm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Cakm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Cakm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Cakm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Cakm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Cakm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cakm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Canadian_Aboriginal}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 47,
+        "raw": "/^\\P{Script_Extensions=Canadian_Aboriginal}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 45,
+          "raw": "^\\P{Script_Extensions=Canadian_Aboriginal}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 45,
+              "raw": "^\\P{Script_Extensions=Canadian_Aboriginal}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 44,
+                  "raw": "\\P{Script_Extensions=Canadian_Aboriginal}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 43,
+                    "raw": "\\P{Script_Extensions=Canadian_Aboriginal}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Canadian_Aboriginal",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 44,
+                  "end": 45,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 46,
+          "end": 47,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Cans}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Cans}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Cans}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Cans}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Cans}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Cans}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cans",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Carian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Carian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Carian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Carian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Carian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Carian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Carian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Cari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Cari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Cari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Cari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Cari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Cari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Caucasian_Albanian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 46,
+        "raw": "/^\\P{Script_Extensions=Caucasian_Albanian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 44,
+          "raw": "^\\P{Script_Extensions=Caucasian_Albanian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 44,
+              "raw": "^\\P{Script_Extensions=Caucasian_Albanian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 43,
+                  "raw": "\\P{Script_Extensions=Caucasian_Albanian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 42,
+                    "raw": "\\P{Script_Extensions=Caucasian_Albanian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Caucasian_Albanian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 43,
+                  "end": 44,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 45,
+          "end": 46,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Chakma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Chakma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Chakma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Chakma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Chakma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Chakma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Chakma",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Cham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Cham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Cham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Cham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Cham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Cham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Cherokee}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Cherokee}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Cherokee}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Cherokee}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Cherokee}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Cherokee}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cherokee",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Cher}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Cher}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Cher}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Cher}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Cher}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Cher}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cher",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Chorasmian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Script_Extensions=Chorasmian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Script_Extensions=Chorasmian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Script_Extensions=Chorasmian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Script_Extensions=Chorasmian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Script_Extensions=Chorasmian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Chorasmian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Chrs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Chrs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Chrs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Chrs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Chrs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Chrs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Chrs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Common}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Common}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Common}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Common}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Common}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Common}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Common",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Coptic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Coptic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Coptic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Coptic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Coptic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Coptic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Coptic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Copt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Copt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Copt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Copt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Copt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Copt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Copt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Cpmn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Cpmn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Cpmn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Cpmn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Cpmn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Cpmn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cpmn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Cprt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Cprt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Cprt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Cprt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Cprt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Cprt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cprt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Cuneiform}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{Script_Extensions=Cuneiform}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{Script_Extensions=Cuneiform}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{Script_Extensions=Cuneiform}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{Script_Extensions=Cuneiform}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{Script_Extensions=Cuneiform}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cuneiform",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Cypriot}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Cypriot}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Cypriot}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Cypriot}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Cypriot}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Cypriot}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cypriot",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Cypro_Minoan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^\\P{Script_Extensions=Cypro_Minoan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^\\P{Script_Extensions=Cypro_Minoan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^\\P{Script_Extensions=Cypro_Minoan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "\\P{Script_Extensions=Cypro_Minoan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "\\P{Script_Extensions=Cypro_Minoan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cypro_Minoan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Cyrillic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Cyrillic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Cyrillic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Cyrillic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Cyrillic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Cyrillic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cyrillic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Cyrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Cyrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Cyrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Cyrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Cyrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Cyrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cyrl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Deseret}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Deseret}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Deseret}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Deseret}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Deseret}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Deseret}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Deseret",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Devanagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Script_Extensions=Devanagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Script_Extensions=Devanagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Script_Extensions=Devanagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Script_Extensions=Devanagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Script_Extensions=Devanagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Devanagari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Deva}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Deva}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Deva}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Deva}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Deva}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Deva}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Deva",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Diak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Diak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Diak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Diak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Diak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Diak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Diak",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Dives_Akuru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{Script_Extensions=Dives_Akuru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{Script_Extensions=Dives_Akuru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{Script_Extensions=Dives_Akuru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{Script_Extensions=Dives_Akuru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{Script_Extensions=Dives_Akuru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Dives_Akuru",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Dogra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Dogra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Dogra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Dogra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Dogra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Dogra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Dogra",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Dogr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Dogr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Dogr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Dogr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Dogr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Dogr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Dogr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Dsrt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Dsrt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Dsrt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Dsrt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Dsrt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Dsrt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Dsrt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Duployan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Duployan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Duployan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Duployan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Duployan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Duployan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Duployan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Dupl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Dupl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Dupl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Dupl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Dupl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Dupl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Dupl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Egyptian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 48,
+        "raw": "/^\\P{Script_Extensions=Egyptian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 46,
+          "raw": "^\\P{Script_Extensions=Egyptian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 46,
+              "raw": "^\\P{Script_Extensions=Egyptian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 45,
+                  "raw": "\\P{Script_Extensions=Egyptian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 44,
+                    "raw": "\\P{Script_Extensions=Egyptian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Egyptian_Hieroglyphs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 45,
+                  "end": 46,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 47,
+          "end": 48,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Egyp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Egyp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Egyp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Egyp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Egyp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Egyp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Egyp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Elbasan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Elbasan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Elbasan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Elbasan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Elbasan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Elbasan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Elbasan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Elba}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Elba}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Elba}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Elba}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Elba}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Elba}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Elba",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Elymaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Elymaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Elymaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Elymaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Elymaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Elymaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Elymaic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Elym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Elym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Elym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Elym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Elym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Elym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Elym",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Ethiopic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Ethiopic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Ethiopic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Ethiopic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Ethiopic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Ethiopic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ethiopic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Ethi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Ethi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Ethi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Ethi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Ethi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Ethi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ethi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Georgian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Georgian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Georgian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Georgian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Georgian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Georgian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Georgian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Geor}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Geor}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Geor}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Geor}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Geor}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Geor}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Geor",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Glagolitic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Script_Extensions=Glagolitic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Script_Extensions=Glagolitic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Script_Extensions=Glagolitic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Script_Extensions=Glagolitic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Script_Extensions=Glagolitic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Glagolitic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Glag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Glag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Glag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Glag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Glag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Glag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Glag",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Gong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Gong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Gong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Gong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Gong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Gong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Gonm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Gonm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Gonm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Gonm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Gonm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Gonm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gonm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Gothic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Gothic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Gothic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Gothic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Gothic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Gothic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gothic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Goth}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Goth}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Goth}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Goth}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Goth}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Goth}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Goth",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Grantha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Grantha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Grantha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Grantha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Grantha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Grantha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Grantha",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Gran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Gran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Gran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Gran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Gran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Gran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gran",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Greek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Greek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Greek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Greek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Greek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Greek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Greek",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Grek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Grek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Grek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Grek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Grek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Grek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Grek",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Gujarati}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Gujarati}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Gujarati}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Gujarati}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Gujarati}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Gujarati}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gujarati",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Gujr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Gujr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Gujr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Gujr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Gujr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Gujr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gujr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Gunjala_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\P{Script_Extensions=Gunjala_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\P{Script_Extensions=Gunjala_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\P{Script_Extensions=Gunjala_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\P{Script_Extensions=Gunjala_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\P{Script_Extensions=Gunjala_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gunjala_Gondi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Gurmukhi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Gurmukhi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Gurmukhi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Gurmukhi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Gurmukhi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Gurmukhi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gurmukhi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Guru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Guru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Guru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Guru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Guru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Guru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Guru",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hangul}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Hangul}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Hangul}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Hangul}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Hangul}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Hangul}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hangul",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Hang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Hang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Hang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Hang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Hang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hang",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hanifi_Rohingya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\P{Script_Extensions=Hanifi_Rohingya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\P{Script_Extensions=Hanifi_Rohingya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\P{Script_Extensions=Hanifi_Rohingya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\P{Script_Extensions=Hanifi_Rohingya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\P{Script_Extensions=Hanifi_Rohingya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hanifi_Rohingya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Hani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Hani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Hani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Hani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Hani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hano}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Hano}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Hano}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Hano}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Hano}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Hano}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hano",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hanunoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Hanunoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Hanunoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Hanunoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Hanunoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Hanunoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hanunoo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Han}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\P{Script_Extensions=Han}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\P{Script_Extensions=Han}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\P{Script_Extensions=Han}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\P{Script_Extensions=Han}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\P{Script_Extensions=Han}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Han",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hatran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Hatran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Hatran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Hatran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Hatran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Hatran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hatran",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hatr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Hatr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Hatr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Hatr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Hatr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Hatr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hatr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hebrew}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Hebrew}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Hebrew}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Hebrew}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Hebrew}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Hebrew}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hebrew",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hebr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Hebr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Hebr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Hebr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Hebr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Hebr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hebr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hiragana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Hiragana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Hiragana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Hiragana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Hiragana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Hiragana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hiragana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hira}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Hira}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Hira}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Hira}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Hira}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Hira}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hira",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hluw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Hluw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Hluw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Hluw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Hluw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Hluw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hluw",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hmng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Hmng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Hmng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Hmng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Hmng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Hmng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hmng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hmnp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Hmnp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Hmnp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Hmnp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Hmnp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Hmnp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hmnp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Hung}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Hung}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Hung}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Hung}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Hung}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Hung}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hung",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Imperial_Aramaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/^\\P{Script_Extensions=Imperial_Aramaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 42,
+          "raw": "^\\P{Script_Extensions=Imperial_Aramaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 42,
+              "raw": "^\\P{Script_Extensions=Imperial_Aramaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 41,
+                  "raw": "\\P{Script_Extensions=Imperial_Aramaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 40,
+                    "raw": "\\P{Script_Extensions=Imperial_Aramaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Imperial_Aramaic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 41,
+                  "end": 42,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 43,
+          "end": 44,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Inherited}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{Script_Extensions=Inherited}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{Script_Extensions=Inherited}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{Script_Extensions=Inherited}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{Script_Extensions=Inherited}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{Script_Extensions=Inherited}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Inherited",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Inscriptional_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 49,
+        "raw": "/^\\P{Script_Extensions=Inscriptional_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 47,
+          "raw": "^\\P{Script_Extensions=Inscriptional_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 47,
+              "raw": "^\\P{Script_Extensions=Inscriptional_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 46,
+                  "raw": "\\P{Script_Extensions=Inscriptional_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 45,
+                    "raw": "\\P{Script_Extensions=Inscriptional_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Inscriptional_Pahlavi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 46,
+                  "end": 47,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 48,
+          "end": 49,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Inscriptional_Parthian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 50,
+        "raw": "/^\\P{Script_Extensions=Inscriptional_Parthian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 48,
+          "raw": "^\\P{Script_Extensions=Inscriptional_Parthian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 48,
+              "raw": "^\\P{Script_Extensions=Inscriptional_Parthian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 47,
+                  "raw": "\\P{Script_Extensions=Inscriptional_Parthian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 46,
+                    "raw": "\\P{Script_Extensions=Inscriptional_Parthian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Inscriptional_Parthian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 47,
+                  "end": 48,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 49,
+          "end": 50,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Ital}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Ital}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Ital}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Ital}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Ital}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Ital}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ital",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Javanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Javanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Javanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Javanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Javanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Javanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Javanese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Java}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Java}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Java}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Java}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Java}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Java}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Java",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Kaithi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Kaithi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Kaithi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Kaithi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Kaithi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Kaithi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kaithi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Kali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Kali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Kali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Kali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Kali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Kali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kali",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Kana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Kana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Kana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Kana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Kana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Kana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Kannada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Kannada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Kannada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Kannada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Kannada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Kannada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kannada",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Katakana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Katakana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Katakana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Katakana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Katakana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Katakana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Katakana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Kawi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Kawi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Kawi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Kawi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Kawi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Kawi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kawi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Kayah_Li}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Kayah_Li}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Kayah_Li}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Kayah_Li}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Kayah_Li}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Kayah_Li}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kayah_Li",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Kharoshthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Script_Extensions=Kharoshthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Script_Extensions=Kharoshthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Script_Extensions=Kharoshthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Script_Extensions=Kharoshthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Script_Extensions=Kharoshthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kharoshthi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Khar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Khar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Khar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Khar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Khar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Khar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Khitan_Small_Script}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 47,
+        "raw": "/^\\P{Script_Extensions=Khitan_Small_Script}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 45,
+          "raw": "^\\P{Script_Extensions=Khitan_Small_Script}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 45,
+              "raw": "^\\P{Script_Extensions=Khitan_Small_Script}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 44,
+                  "raw": "\\P{Script_Extensions=Khitan_Small_Script}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 43,
+                    "raw": "\\P{Script_Extensions=Khitan_Small_Script}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khitan_Small_Script",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 44,
+                  "end": 45,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 46,
+          "end": 47,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Khmer}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Khmer}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Khmer}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Khmer}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Khmer}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Khmer}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khmer",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Khmr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Khmr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Khmr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Khmr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Khmr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Khmr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khmr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Khojki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Khojki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Khojki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Khojki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Khojki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Khojki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khojki",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Khoj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Khoj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Khoj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Khoj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Khoj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Khoj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khoj",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Khudawadi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{Script_Extensions=Khudawadi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{Script_Extensions=Khudawadi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{Script_Extensions=Khudawadi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{Script_Extensions=Khudawadi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{Script_Extensions=Khudawadi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khudawadi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Kits}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Kits}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Kits}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Kits}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Kits}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Kits}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kits",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Knda}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Knda}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Knda}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Knda}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Knda}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Knda}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Knda",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Kthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Kthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Kthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Kthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Kthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Kthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kthi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Lana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Lana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Lana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Lana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Lana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Lana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Laoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Laoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Laoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Laoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Laoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Laoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Laoo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Lao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\P{Script_Extensions=Lao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\P{Script_Extensions=Lao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\P{Script_Extensions=Lao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\P{Script_Extensions=Lao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\P{Script_Extensions=Lao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lao",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Latin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Latin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Latin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Latin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Latin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Latin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Latin",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Latn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Latn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Latn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Latn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Latn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Latn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Latn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Lepcha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Lepcha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Lepcha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Lepcha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Lepcha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Lepcha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lepcha",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Lepc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Lepc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Lepc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Lepc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Lepc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Lepc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lepc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Limbu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Limbu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Limbu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Limbu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Limbu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Limbu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Limbu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Limb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Limb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Limb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Limb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Limb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Limb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Limb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Lina}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Lina}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Lina}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Lina}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Lina}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Lina}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lina",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Linb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Linb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Linb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Linb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Linb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Linb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Linb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Linear_A}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Linear_A}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Linear_A}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Linear_A}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Linear_A}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Linear_A}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Linear_A",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Linear_B}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Linear_B}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Linear_B}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Linear_B}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Linear_B}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Linear_B}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Linear_B",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Lisu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Lisu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Lisu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Lisu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Lisu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Lisu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lisu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Lycian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Lycian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Lycian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Lycian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Lycian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Lycian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lycian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Lyci}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Lyci}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Lyci}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Lyci}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Lyci}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Lyci}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lyci",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Lydian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Lydian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Lydian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Lydian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Lydian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Lydian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lydian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Lydi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Lydi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Lydi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Lydi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Lydi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Lydi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lydi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mahajani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Mahajani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Mahajani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Mahajani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Mahajani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Mahajani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mahajani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mahj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Mahj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Mahj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Mahj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Mahj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Mahj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mahj",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Makasar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Makasar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Makasar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Makasar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Makasar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Makasar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Makasar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Maka}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Maka}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Maka}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Maka}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Maka}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Maka}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Maka",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Malayalam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{Script_Extensions=Malayalam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{Script_Extensions=Malayalam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{Script_Extensions=Malayalam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{Script_Extensions=Malayalam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{Script_Extensions=Malayalam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Malayalam",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mandaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Mandaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Mandaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Mandaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Mandaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Mandaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mandaic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Mand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Mand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Mand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Mand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Mand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mand",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Manichaean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Script_Extensions=Manichaean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Script_Extensions=Manichaean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Script_Extensions=Manichaean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Script_Extensions=Manichaean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Script_Extensions=Manichaean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Manichaean",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Mani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Mani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Mani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Mani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Mani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Marchen}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Marchen}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Marchen}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Marchen}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Marchen}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Marchen}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Marchen",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Marc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Marc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Marc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Marc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Marc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Marc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Marc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Masaram_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\P{Script_Extensions=Masaram_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\P{Script_Extensions=Masaram_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\P{Script_Extensions=Masaram_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\P{Script_Extensions=Masaram_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\P{Script_Extensions=Masaram_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Masaram_Gondi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Medefaidrin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{Script_Extensions=Medefaidrin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{Script_Extensions=Medefaidrin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{Script_Extensions=Medefaidrin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{Script_Extensions=Medefaidrin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{Script_Extensions=Medefaidrin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Medefaidrin",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Medf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Medf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Medf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Medf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Medf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Medf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Medf",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Meetei_Mayek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^\\P{Script_Extensions=Meetei_Mayek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^\\P{Script_Extensions=Meetei_Mayek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^\\P{Script_Extensions=Meetei_Mayek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "\\P{Script_Extensions=Meetei_Mayek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "\\P{Script_Extensions=Meetei_Mayek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Meetei_Mayek",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mende_Kikakui}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\P{Script_Extensions=Mende_Kikakui}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\P{Script_Extensions=Mende_Kikakui}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\P{Script_Extensions=Mende_Kikakui}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\P{Script_Extensions=Mende_Kikakui}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\P{Script_Extensions=Mende_Kikakui}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mende_Kikakui",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mend}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Mend}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Mend}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Mend}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Mend}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Mend}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mend",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Merc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Merc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Merc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Merc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Merc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Merc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Merc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Meroitic_Cursive}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/^\\P{Script_Extensions=Meroitic_Cursive}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 42,
+          "raw": "^\\P{Script_Extensions=Meroitic_Cursive}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 42,
+              "raw": "^\\P{Script_Extensions=Meroitic_Cursive}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 41,
+                  "raw": "\\P{Script_Extensions=Meroitic_Cursive}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 40,
+                    "raw": "\\P{Script_Extensions=Meroitic_Cursive}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Meroitic_Cursive",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 41,
+                  "end": 42,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 43,
+          "end": 44,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Meroitic_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 48,
+        "raw": "/^\\P{Script_Extensions=Meroitic_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 46,
+          "raw": "^\\P{Script_Extensions=Meroitic_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 46,
+              "raw": "^\\P{Script_Extensions=Meroitic_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 45,
+                  "raw": "\\P{Script_Extensions=Meroitic_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 44,
+                    "raw": "\\P{Script_Extensions=Meroitic_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Meroitic_Hieroglyphs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 45,
+                  "end": 46,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 47,
+          "end": 48,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mero}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Mero}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Mero}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Mero}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Mero}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Mero}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mero",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Miao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Miao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Miao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Miao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Miao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Miao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Miao",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mlym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Mlym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Mlym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Mlym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Mlym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Mlym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mlym",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Modi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Modi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Modi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Modi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Modi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Modi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Modi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mongolian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{Script_Extensions=Mongolian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{Script_Extensions=Mongolian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{Script_Extensions=Mongolian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{Script_Extensions=Mongolian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{Script_Extensions=Mongolian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mongolian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Mong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Mong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Mong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Mong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Mong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mroo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Mroo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Mroo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Mroo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Mroo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Mroo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mroo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mro}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\P{Script_Extensions=Mro}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\P{Script_Extensions=Mro}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\P{Script_Extensions=Mro}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\P{Script_Extensions=Mro}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\P{Script_Extensions=Mro}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mro",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mtei}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Mtei}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Mtei}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Mtei}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Mtei}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Mtei}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mtei",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Multani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Multani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Multani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Multani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Multani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Multani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Multani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mult}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Mult}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Mult}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Mult}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Mult}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Mult}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mult",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Myanmar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Myanmar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Myanmar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Myanmar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Myanmar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Myanmar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Myanmar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Mymr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Mymr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Mymr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Mymr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Mymr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Mymr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mymr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Nabataean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{Script_Extensions=Nabataean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{Script_Extensions=Nabataean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{Script_Extensions=Nabataean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{Script_Extensions=Nabataean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{Script_Extensions=Nabataean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nabataean",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Nag_Mundari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{Script_Extensions=Nag_Mundari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{Script_Extensions=Nag_Mundari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{Script_Extensions=Nag_Mundari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{Script_Extensions=Nag_Mundari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{Script_Extensions=Nag_Mundari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nag_Mundari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Nagm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Nagm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Nagm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Nagm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Nagm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Nagm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nagm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Nandinagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{Script_Extensions=Nandinagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{Script_Extensions=Nandinagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{Script_Extensions=Nandinagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{Script_Extensions=Nandinagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{Script_Extensions=Nandinagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nandinagari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Nand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Nand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Nand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Nand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Nand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Nand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nand",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Narb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Narb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Narb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Narb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Narb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Narb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Narb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Nbat}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Nbat}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Nbat}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Nbat}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Nbat}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Nbat}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nbat",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=New_Tai_Lue}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{Script_Extensions=New_Tai_Lue}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{Script_Extensions=New_Tai_Lue}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{Script_Extensions=New_Tai_Lue}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{Script_Extensions=New_Tai_Lue}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{Script_Extensions=New_Tai_Lue}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "New_Tai_Lue",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Newa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Newa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Newa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Newa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Newa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Newa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Newa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Nkoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Nkoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Nkoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Nkoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Nkoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Nkoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nkoo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Nko}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\P{Script_Extensions=Nko}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\P{Script_Extensions=Nko}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\P{Script_Extensions=Nko}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\P{Script_Extensions=Nko}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\P{Script_Extensions=Nko}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nko",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Nshu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Nshu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Nshu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Nshu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Nshu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Nshu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nshu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Nushu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Nushu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Nushu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Nushu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Nushu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Nushu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nushu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Nyiakeng_Puachue_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 50,
+        "raw": "/^\\P{Script_Extensions=Nyiakeng_Puachue_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 48,
+          "raw": "^\\P{Script_Extensions=Nyiakeng_Puachue_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 48,
+              "raw": "^\\P{Script_Extensions=Nyiakeng_Puachue_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 47,
+                  "raw": "\\P{Script_Extensions=Nyiakeng_Puachue_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 46,
+                    "raw": "\\P{Script_Extensions=Nyiakeng_Puachue_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nyiakeng_Puachue_Hmong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 47,
+                  "end": 48,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 49,
+          "end": 50,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Ogam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Ogam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Ogam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Ogam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Ogam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Ogam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ogam",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Ogham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Ogham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Ogham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Ogham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Ogham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Ogham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ogham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Ol_Chiki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Ol_Chiki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Ol_Chiki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Ol_Chiki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Ol_Chiki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Ol_Chiki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ol_Chiki",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Olck}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Olck}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Olck}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Olck}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Olck}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Olck}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Olck",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Old_Hungarian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\P{Script_Extensions=Old_Hungarian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\P{Script_Extensions=Old_Hungarian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\P{Script_Extensions=Old_Hungarian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\P{Script_Extensions=Old_Hungarian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\P{Script_Extensions=Old_Hungarian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Hungarian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Old_Italic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Script_Extensions=Old_Italic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Script_Extensions=Old_Italic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Script_Extensions=Old_Italic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Script_Extensions=Old_Italic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Script_Extensions=Old_Italic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Italic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Old_North_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 45,
+        "raw": "/^\\P{Script_Extensions=Old_North_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 43,
+          "raw": "^\\P{Script_Extensions=Old_North_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 43,
+              "raw": "^\\P{Script_Extensions=Old_North_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 42,
+                  "raw": "\\P{Script_Extensions=Old_North_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 41,
+                    "raw": "\\P{Script_Extensions=Old_North_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_North_Arabian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 42,
+                  "end": 43,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 44,
+          "end": 45,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Old_Permic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Script_Extensions=Old_Permic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Script_Extensions=Old_Permic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Script_Extensions=Old_Permic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Script_Extensions=Old_Permic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Script_Extensions=Old_Permic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Permic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Old_Persian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{Script_Extensions=Old_Persian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{Script_Extensions=Old_Persian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{Script_Extensions=Old_Persian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{Script_Extensions=Old_Persian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{Script_Extensions=Old_Persian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Persian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Old_Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{Script_Extensions=Old_Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{Script_Extensions=Old_Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{Script_Extensions=Old_Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{Script_Extensions=Old_Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{Script_Extensions=Old_Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Sogdian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Old_South_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 45,
+        "raw": "/^\\P{Script_Extensions=Old_South_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 43,
+          "raw": "^\\P{Script_Extensions=Old_South_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 43,
+              "raw": "^\\P{Script_Extensions=Old_South_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 42,
+                  "raw": "\\P{Script_Extensions=Old_South_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 41,
+                    "raw": "\\P{Script_Extensions=Old_South_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_South_Arabian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 42,
+                  "end": 43,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 44,
+          "end": 45,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Old_Turkic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Script_Extensions=Old_Turkic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Script_Extensions=Old_Turkic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Script_Extensions=Old_Turkic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Script_Extensions=Old_Turkic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Script_Extensions=Old_Turkic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Turkic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Old_Uyghur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Script_Extensions=Old_Uyghur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Script_Extensions=Old_Uyghur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Script_Extensions=Old_Uyghur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Script_Extensions=Old_Uyghur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Script_Extensions=Old_Uyghur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Uyghur",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Oriya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Oriya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Oriya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Oriya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Oriya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Oriya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Oriya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Orkh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Orkh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Orkh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Orkh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Orkh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Orkh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Orkh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Orya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Orya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Orya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Orya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Orya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Orya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Orya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Osage}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Osage}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Osage}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Osage}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Osage}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Osage}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Osage",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Osge}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Osge}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Osge}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Osge}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Osge}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Osge}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Osge",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Osmanya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Osmanya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Osmanya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Osmanya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Osmanya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Osmanya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Osmanya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Osma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Osma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Osma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Osma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Osma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Osma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Osma",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Ougr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Ougr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Ougr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Ougr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Ougr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Ougr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ougr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Pahawh_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^\\P{Script_Extensions=Pahawh_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^\\P{Script_Extensions=Pahawh_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^\\P{Script_Extensions=Pahawh_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "\\P{Script_Extensions=Pahawh_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "\\P{Script_Extensions=Pahawh_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Pahawh_Hmong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Palmyrene}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{Script_Extensions=Palmyrene}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{Script_Extensions=Palmyrene}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{Script_Extensions=Palmyrene}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{Script_Extensions=Palmyrene}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{Script_Extensions=Palmyrene}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Palmyrene",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Palm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Palm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Palm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Palm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Palm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Palm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Palm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Pau_Cin_Hau}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{Script_Extensions=Pau_Cin_Hau}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{Script_Extensions=Pau_Cin_Hau}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{Script_Extensions=Pau_Cin_Hau}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{Script_Extensions=Pau_Cin_Hau}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{Script_Extensions=Pau_Cin_Hau}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Pau_Cin_Hau",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Pauc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Pauc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Pauc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Pauc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Pauc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Pauc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Pauc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Perm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Perm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Perm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Perm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Perm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Perm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Perm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Phags_Pa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Phags_Pa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Phags_Pa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Phags_Pa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Phags_Pa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Phags_Pa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Phags_Pa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Phag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Phag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Phag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Phag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Phag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Phag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Phag",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Phli}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Phli}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Phli}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Phli}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Phli}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Phli}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Phli",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Phlp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Phlp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Phlp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Phlp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Phlp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Phlp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Phlp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Phnx}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Phnx}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Phnx}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Phnx}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Phnx}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Phnx}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Phnx",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Phoenician}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Script_Extensions=Phoenician}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Script_Extensions=Phoenician}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Script_Extensions=Phoenician}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Script_Extensions=Phoenician}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Script_Extensions=Phoenician}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Phoenician",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Plrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Plrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Plrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Plrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Plrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Plrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Plrd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Prti}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Prti}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Prti}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Prti}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Prti}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Prti}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Prti",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Psalter_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\P{Script_Extensions=Psalter_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\P{Script_Extensions=Psalter_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\P{Script_Extensions=Psalter_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\P{Script_Extensions=Psalter_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\P{Script_Extensions=Psalter_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Psalter_Pahlavi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Qaac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Qaac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Qaac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Qaac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Qaac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Qaac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Qaac",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Qaai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Qaai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Qaai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Qaai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Qaai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Qaai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Qaai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Rejang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Rejang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Rejang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Rejang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Rejang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Rejang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Rejang",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Rjng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Rjng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Rjng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Rjng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Rjng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Rjng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Rjng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Rohg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Rohg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Rohg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Rohg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Rohg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Rohg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Rohg",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Runic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Runic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Runic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Runic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Runic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Runic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Runic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Runr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Runr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Runr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Runr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Runr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Runr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Runr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Samaritan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{Script_Extensions=Samaritan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{Script_Extensions=Samaritan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{Script_Extensions=Samaritan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{Script_Extensions=Samaritan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{Script_Extensions=Samaritan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Samaritan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Samr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Samr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Samr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Samr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Samr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Samr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Samr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sarb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Sarb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Sarb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Sarb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Sarb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Sarb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sarb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Saurashtra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\P{Script_Extensions=Saurashtra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\P{Script_Extensions=Saurashtra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\P{Script_Extensions=Saurashtra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\P{Script_Extensions=Saurashtra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\P{Script_Extensions=Saurashtra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Saurashtra",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Saur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Saur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Saur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Saur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Saur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Saur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Saur",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sgnw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Sgnw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Sgnw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Sgnw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Sgnw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Sgnw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sgnw",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sharada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Sharada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Sharada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Sharada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Sharada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Sharada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sharada",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Shavian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Shavian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Shavian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Shavian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Shavian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Shavian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Shavian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Shaw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Shaw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Shaw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Shaw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Shaw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Shaw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Shaw",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Shrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Shrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Shrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Shrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Shrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Shrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Shrd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Siddham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Siddham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Siddham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Siddham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Siddham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Siddham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Siddham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sidd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Sidd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Sidd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Sidd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Sidd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Sidd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sidd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=SignWriting}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{Script_Extensions=SignWriting}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{Script_Extensions=SignWriting}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{Script_Extensions=SignWriting}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{Script_Extensions=SignWriting}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{Script_Extensions=SignWriting}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "SignWriting",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sind}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Sind}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Sind}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Sind}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Sind}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Sind}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sind",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sinhala}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Sinhala}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Sinhala}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Sinhala}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Sinhala}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Sinhala}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sinhala",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Sinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Sinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Sinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Sinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Sinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sinh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sogdian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sogd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Sogd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Sogd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Sogd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Sogd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Sogd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sogd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sogo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Sogo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Sogo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Sogo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Sogo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Sogo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sogo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sora_Sompeng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^\\P{Script_Extensions=Sora_Sompeng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^\\P{Script_Extensions=Sora_Sompeng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^\\P{Script_Extensions=Sora_Sompeng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "\\P{Script_Extensions=Sora_Sompeng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "\\P{Script_Extensions=Sora_Sompeng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sora_Sompeng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sora}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Sora}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Sora}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Sora}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Sora}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Sora}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sora",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Soyombo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Soyombo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Soyombo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Soyombo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Soyombo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Soyombo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Soyombo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Soyo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Soyo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Soyo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Soyo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Soyo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Soyo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Soyo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sundanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\P{Script_Extensions=Sundanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\P{Script_Extensions=Sundanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\P{Script_Extensions=Sundanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\P{Script_Extensions=Sundanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\P{Script_Extensions=Sundanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sundanese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sund}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Sund}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Sund}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Sund}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Sund}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Sund}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sund",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Syloti_Nagri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^\\P{Script_Extensions=Syloti_Nagri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^\\P{Script_Extensions=Syloti_Nagri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^\\P{Script_Extensions=Syloti_Nagri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "\\P{Script_Extensions=Syloti_Nagri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "\\P{Script_Extensions=Syloti_Nagri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Syloti_Nagri",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Sylo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Sylo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Sylo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Sylo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Sylo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Sylo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sylo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Syrc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Syrc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Syrc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Syrc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Syrc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Syrc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Syrc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Syriac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Syriac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Syriac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Syriac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Syriac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Syriac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Syriac",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tagalog}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Tagalog}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Tagalog}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Tagalog}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Tagalog}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Tagalog}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tagalog",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tagbanwa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Tagbanwa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Tagbanwa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Tagbanwa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Tagbanwa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Tagbanwa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tagbanwa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tagb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Tagb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Tagb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Tagb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Tagb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Tagb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tagb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tai_Le}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Tai_Le}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Tai_Le}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Tai_Le}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Tai_Le}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Tai_Le}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tai_Le",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tai_Tham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Tai_Tham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Tai_Tham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Tai_Tham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Tai_Tham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Tai_Tham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tai_Tham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tai_Viet}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Tai_Viet}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Tai_Viet}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Tai_Viet}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Tai_Viet}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Tai_Viet}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tai_Viet",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Takri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Takri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Takri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Takri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Takri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Takri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Takri",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Takr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Takr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Takr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Takr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Takr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Takr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Takr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tale}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Tale}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Tale}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Tale}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Tale}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Tale}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tale",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Talu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Talu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Talu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Talu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Talu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Talu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Talu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tamil}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{Script_Extensions=Tamil}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{Script_Extensions=Tamil}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{Script_Extensions=Tamil}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{Script_Extensions=Tamil}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{Script_Extensions=Tamil}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tamil",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Taml}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Taml}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Taml}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Taml}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Taml}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Taml}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Taml",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tangsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Tangsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Tangsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Tangsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Tangsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Tangsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tangsa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tangut}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Tangut}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Tangut}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Tangut}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Tangut}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Tangut}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tangut",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Tang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Tang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Tang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Tang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Tang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tang",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tavt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Tavt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Tavt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Tavt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Tavt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Tavt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tavt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Telugu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Telugu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Telugu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Telugu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Telugu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Telugu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Telugu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Telu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Telu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Telu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Telu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Telu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Telu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Telu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tfng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Tfng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Tfng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Tfng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Tfng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Tfng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tfng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tglg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Tglg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Tglg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Tglg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Tglg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Tglg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tglg",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Thaana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Thaana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Thaana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Thaana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Thaana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Thaana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Thaana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Thaa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Thaa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Thaa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Thaa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Thaa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Thaa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Thaa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Thai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Thai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Thai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Thai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Thai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Thai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Thai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tibetan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Tibetan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Tibetan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Tibetan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Tibetan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Tibetan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tibetan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tibt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Tibt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Tibt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Tibt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Tibt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Tibt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tibt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tifinagh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Tifinagh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Tifinagh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Tifinagh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Tifinagh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Tifinagh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tifinagh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tirhuta}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{Script_Extensions=Tirhuta}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{Script_Extensions=Tirhuta}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{Script_Extensions=Tirhuta}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{Script_Extensions=Tirhuta}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{Script_Extensions=Tirhuta}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tirhuta",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tirh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Tirh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Tirh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Tirh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Tirh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Tirh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tirh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Tnsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Tnsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Tnsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Tnsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Tnsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Tnsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tnsa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Toto}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Toto}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Toto}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Toto}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Toto}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Toto}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Toto",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Ugaritic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Ugaritic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Ugaritic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Ugaritic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Ugaritic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Ugaritic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ugaritic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Ugar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Ugar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Ugar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Ugar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Ugar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Ugar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ugar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Vaii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Vaii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Vaii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Vaii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Vaii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Vaii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Vaii",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Vai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\P{Script_Extensions=Vai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\P{Script_Extensions=Vai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\P{Script_Extensions=Vai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\P{Script_Extensions=Vai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\P{Script_Extensions=Vai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Vai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Vithkuqi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{Script_Extensions=Vithkuqi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{Script_Extensions=Vithkuqi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{Script_Extensions=Vithkuqi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{Script_Extensions=Vithkuqi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{Script_Extensions=Vithkuqi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Vithkuqi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Vith}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Vith}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Vith}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Vith}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Vith}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Vith}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Vith",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Wancho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Wancho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Wancho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Wancho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Wancho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Wancho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Wancho",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Warang_Citi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\P{Script_Extensions=Warang_Citi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\P{Script_Extensions=Warang_Citi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\P{Script_Extensions=Warang_Citi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\P{Script_Extensions=Warang_Citi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\P{Script_Extensions=Warang_Citi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Warang_Citi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Wara}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Wara}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Wara}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Wara}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Wara}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Wara}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Wara",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Wcho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Wcho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Wcho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Wcho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Wcho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Wcho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Wcho",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Xpeo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Xpeo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Xpeo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Xpeo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Xpeo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Xpeo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Xpeo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Xsux}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Xsux}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Xsux}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Xsux}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Xsux}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Xsux}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Xsux",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Yezidi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{Script_Extensions=Yezidi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{Script_Extensions=Yezidi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{Script_Extensions=Yezidi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{Script_Extensions=Yezidi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{Script_Extensions=Yezidi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Yezidi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Yezi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Yezi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Yezi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Yezi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Yezi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Yezi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Yezi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Yiii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Yiii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Yiii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Yiii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Yiii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Yiii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Yiii",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Yi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{Script_Extensions=Yi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{Script_Extensions=Yi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{Script_Extensions=Yi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{Script_Extensions=Yi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{Script_Extensions=Yi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Yi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Zanabazar_Square}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/^\\P{Script_Extensions=Zanabazar_Square}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 42,
+          "raw": "^\\P{Script_Extensions=Zanabazar_Square}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 42,
+              "raw": "^\\P{Script_Extensions=Zanabazar_Square}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 41,
+                  "raw": "\\P{Script_Extensions=Zanabazar_Square}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 40,
+                    "raw": "\\P{Script_Extensions=Zanabazar_Square}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Zanabazar_Square",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 41,
+                  "end": 42,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 43,
+          "end": 44,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Zanb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Zanb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Zanb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Zanb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Zanb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Zanb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Zanb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Zinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Zinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Zinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Zinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Zinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Zinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Zinh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Script_Extensions=Zyyy}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{Script_Extensions=Zyyy}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{Script_Extensions=Zyyy}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{Script_Extensions=Zyyy}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{Script_Extensions=Zyyy}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{Script_Extensions=Zyyy}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Zyyy",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Sc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Sc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Sc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Sc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Sc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Sc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Sc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Sentence_Terminal}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Sentence_Terminal}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Sentence_Terminal}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Sentence_Terminal}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Sentence_Terminal}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Sentence_Terminal}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Sentence_Terminal",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Separator",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Sk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Sk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Sk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Sk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Sk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Sk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Sk",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Sm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Sm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Sm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Sm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Sm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Sm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Sm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Soft_Dotted}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{Soft_Dotted}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{Soft_Dotted}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{Soft_Dotted}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{Soft_Dotted}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{Soft_Dotted}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Soft_Dotted",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{So}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{So}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{So}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{So}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{So}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{So}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "So",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Space_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{Space_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{Space_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{Space_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{Space_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{Space_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Space_Separator",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Spacing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{Spacing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{Spacing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{Spacing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{Spacing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{Spacing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Spacing_Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Surrogate}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{Surrogate}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{Surrogate}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{Surrogate}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{Surrogate}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{Surrogate}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Surrogate",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{S}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\P{S}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\P{S}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\P{S}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\P{S}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\P{S}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "S",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Terminal_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{Terminal_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{Terminal_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{Terminal_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{Terminal_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{Terminal_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Terminal_Punctuation",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Term}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{Term}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{Term}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{Term}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{Term}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{Term}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Term",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Titlecase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Titlecase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Titlecase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Titlecase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Titlecase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Titlecase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Titlecase_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{UIdeo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{UIdeo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{UIdeo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{UIdeo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{UIdeo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{UIdeo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "UIdeo",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Unassigned}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{Unassigned}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{Unassigned}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{Unassigned}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{Unassigned}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{Unassigned}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Unassigned",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Unified_Ideograph}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{Unified_Ideograph}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{Unified_Ideograph}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{Unified_Ideograph}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{Unified_Ideograph}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{Unified_Ideograph}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Unified_Ideograph",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Uppercase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{Uppercase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{Uppercase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{Uppercase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{Uppercase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{Uppercase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Uppercase_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Uppercase}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{Uppercase}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{Uppercase}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{Uppercase}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{Uppercase}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{Uppercase}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Uppercase",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Upper}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{Upper}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{Upper}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{Upper}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{Upper}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{Upper}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Upper",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{VS}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{VS}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{VS}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{VS}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{VS}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{VS}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "VS",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Variation_Selector}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{Variation_Selector}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{Variation_Selector}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{Variation_Selector}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{Variation_Selector}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{Variation_Selector}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Variation_Selector",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{White_Space}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{White_Space}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{White_Space}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{White_Space}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{White_Space}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{White_Space}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "White_Space",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{XIDC}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{XIDC}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{XIDC}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{XIDC}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{XIDC}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{XIDC}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "XIDC",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{XIDS}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{XIDS}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{XIDS}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{XIDS}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{XIDS}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{XIDS}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "XIDS",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{XID_Continue}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{XID_Continue}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{XID_Continue}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{XID_Continue}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{XID_Continue}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{XID_Continue}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "XID_Continue",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{XID_Start}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{XID_Start}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{XID_Start}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{XID_Start}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{XID_Start}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{XID_Start}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "XID_Start",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Zl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Zl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Zl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Zl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Zl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Zl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Zl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Zp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Zp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Zp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Zp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Zp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Zp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Zp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Zs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\P{Zs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\P{Zs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\P{Zs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\P{Zs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\P{Zs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Zs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{Z}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\P{Z}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\P{Z}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\P{Z}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\P{Z}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\P{Z}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Z",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{cntrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{cntrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{cntrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{cntrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{cntrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{cntrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "cntrl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{digit}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{digit}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{digit}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{digit}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{digit}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{digit}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "digit",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Cased_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{gc=Cased_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{gc=Cased_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{gc=Cased_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{gc=Cased_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{gc=Cased_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Cased_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Cc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Cc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Cc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Cc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Cc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Cc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Cc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Cf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Cf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Cf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Cf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Cf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Cf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Cf",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Close_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{gc=Close_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{gc=Close_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{gc=Close_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{gc=Close_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{gc=Close_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Close_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Cn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Cn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Cn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Cn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Cn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Cn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Cn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Combining_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{gc=Combining_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{gc=Combining_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{gc=Combining_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{gc=Combining_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{gc=Combining_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Combining_Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Connector_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{gc=Connector_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{gc=Connector_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{gc=Connector_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{gc=Connector_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{gc=Connector_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Connector_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Control}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{gc=Control}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{gc=Control}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{gc=Control}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{gc=Control}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{gc=Control}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Control",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Co}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Co}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Co}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Co}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Co}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Co}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Co",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Cs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Cs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Cs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Cs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Cs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Cs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Cs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Currency_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{gc=Currency_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{gc=Currency_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{gc=Currency_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{gc=Currency_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{gc=Currency_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Currency_Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=C}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{gc=C}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{gc=C}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{gc=C}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{gc=C}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{gc=C}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "C",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Dash_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{gc=Dash_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{gc=Dash_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{gc=Dash_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{gc=Dash_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{gc=Dash_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Dash_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Decimal_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{gc=Decimal_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{gc=Decimal_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{gc=Decimal_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{gc=Decimal_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{gc=Decimal_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Decimal_Number",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Enclosing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{gc=Enclosing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{gc=Enclosing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{gc=Enclosing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{gc=Enclosing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{gc=Enclosing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Enclosing_Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Final_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{gc=Final_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{gc=Final_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{gc=Final_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{gc=Final_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{gc=Final_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Final_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Format}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{gc=Format}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{gc=Format}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{gc=Format}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{gc=Format}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{gc=Format}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Format",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Initial_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{gc=Initial_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{gc=Initial_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{gc=Initial_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{gc=Initial_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{gc=Initial_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Initial_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=LC}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=LC}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=LC}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=LC}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=LC}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=LC}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "LC",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Letter_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{gc=Letter_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{gc=Letter_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{gc=Letter_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{gc=Letter_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{gc=Letter_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Letter_Number",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{gc=Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{gc=Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{gc=Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{gc=Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{gc=Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Line_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{gc=Line_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{gc=Line_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{gc=Line_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{gc=Line_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{gc=Line_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Line_Separator",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Ll}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Ll}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Ll}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Ll}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Ll}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Ll}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Ll",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Lm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Lm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Lm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Lm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Lm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Lm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Lm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Lowercase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{gc=Lowercase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{gc=Lowercase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{gc=Lowercase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{gc=Lowercase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{gc=Lowercase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Lowercase_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Lo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Lo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Lo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Lo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Lo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Lo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Lo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Lt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Lt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Lt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Lt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Lt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Lt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Lt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Lu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Lu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Lu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Lu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Lu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Lu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Lu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=L}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{gc=L}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{gc=L}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{gc=L}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{gc=L}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{gc=L}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "L",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{gc=Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{gc=Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{gc=Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{gc=Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{gc=Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Math_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{gc=Math_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{gc=Math_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{gc=Math_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{gc=Math_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{gc=Math_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Math_Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Mc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Mc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Mc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Mc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Mc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Mc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Mc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Me}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Me}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Me}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Me}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Me}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Me}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Me",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Mn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Mn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Mn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Mn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Mn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Mn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Mn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Modifier_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{gc=Modifier_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{gc=Modifier_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{gc=Modifier_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{gc=Modifier_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{gc=Modifier_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Modifier_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Modifier_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{gc=Modifier_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{gc=Modifier_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{gc=Modifier_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{gc=Modifier_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{gc=Modifier_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Modifier_Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=M}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{gc=M}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{gc=M}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{gc=M}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{gc=M}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{gc=M}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "M",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Nd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Nd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Nd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Nd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Nd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Nd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Nd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Nl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Nl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Nl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Nl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Nl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Nl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Nl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Nonspacing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{gc=Nonspacing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{gc=Nonspacing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{gc=Nonspacing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{gc=Nonspacing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{gc=Nonspacing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Nonspacing_Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=No}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=No}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=No}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=No}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=No}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=No}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "No",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{gc=Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{gc=Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{gc=Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{gc=Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{gc=Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Number",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=N}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{gc=N}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{gc=N}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{gc=N}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{gc=N}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{gc=N}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "N",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Open_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{gc=Open_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{gc=Open_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{gc=Open_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{gc=Open_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{gc=Open_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Open_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Other_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{gc=Other_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{gc=Other_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{gc=Other_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{gc=Other_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{gc=Other_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Other_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Other_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{gc=Other_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{gc=Other_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{gc=Other_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{gc=Other_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{gc=Other_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Other_Number",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Other_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{gc=Other_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{gc=Other_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{gc=Other_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{gc=Other_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{gc=Other_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Other_Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Other_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{gc=Other_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{gc=Other_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{gc=Other_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{gc=Other_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{gc=Other_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Other_Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Other}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{gc=Other}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{gc=Other}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{gc=Other}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{gc=Other}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{gc=Other}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Other",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Paragraph_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{gc=Paragraph_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{gc=Paragraph_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{gc=Paragraph_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{gc=Paragraph_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{gc=Paragraph_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Paragraph_Separator",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Pc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Pc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Pc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Pc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Pc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Pc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Pc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Pd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Pd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Pd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Pd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Pd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Pd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Pd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Pe}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Pe}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Pe}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Pe}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Pe}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Pe}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Pe",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Pf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Pf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Pf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Pf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Pf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Pf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Pf",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Pi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Pi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Pi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Pi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Pi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Pi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Pi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Po}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Po}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Po}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Po}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Po}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Po}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Po",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Private_Use}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{gc=Private_Use}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{gc=Private_Use}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{gc=Private_Use}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{gc=Private_Use}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{gc=Private_Use}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Private_Use",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Ps}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Ps}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Ps}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Ps}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Ps}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Ps}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Ps",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{gc=Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{gc=Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{gc=Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{gc=Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{gc=Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Punctuation",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=P}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{gc=P}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{gc=P}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{gc=P}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{gc=P}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{gc=P}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "P",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Sc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Sc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Sc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Sc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Sc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Sc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Sc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{gc=Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{gc=Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{gc=Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{gc=Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{gc=Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Separator",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Sk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Sk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Sk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Sk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Sk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Sk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Sk",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Sm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Sm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Sm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Sm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Sm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Sm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Sm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=So}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=So}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=So}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=So}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=So}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=So}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "So",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Space_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{gc=Space_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{gc=Space_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{gc=Space_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{gc=Space_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{gc=Space_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Space_Separator",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Spacing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{gc=Spacing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{gc=Spacing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{gc=Spacing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{gc=Spacing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{gc=Spacing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Spacing_Mark",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Surrogate}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{gc=Surrogate}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{gc=Surrogate}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{gc=Surrogate}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{gc=Surrogate}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{gc=Surrogate}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Surrogate",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{gc=Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{gc=Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{gc=Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{gc=Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{gc=Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Symbol",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=S}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{gc=S}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{gc=S}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{gc=S}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{gc=S}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{gc=S}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "S",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Titlecase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{gc=Titlecase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{gc=Titlecase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{gc=Titlecase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{gc=Titlecase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{gc=Titlecase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Titlecase_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Unassigned}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{gc=Unassigned}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{gc=Unassigned}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{gc=Unassigned}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{gc=Unassigned}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{gc=Unassigned}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Unassigned",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Uppercase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{gc=Uppercase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{gc=Uppercase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{gc=Uppercase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{gc=Uppercase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{gc=Uppercase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Uppercase_Letter",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Zl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Zl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Zl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Zl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Zl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Zl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Zl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Zp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Zp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Zp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Zp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Zp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Zp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Zp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Zs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{gc=Zs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{gc=Zs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{gc=Zs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{gc=Zs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{gc=Zs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Zs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=Z}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\P{gc=Z}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\P{gc=Z}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\P{gc=Z}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\P{gc=Z}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\P{gc=Z}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Z",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=cntrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{gc=cntrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{gc=cntrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{gc=cntrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{gc=cntrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{gc=cntrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "cntrl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=digit}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{gc=digit}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{gc=digit}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{gc=digit}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{gc=digit}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{gc=digit}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "digit",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{gc=punct}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{gc=punct}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{gc=punct}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{gc=punct}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{gc=punct}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{gc=punct}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "punct",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{punct}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{punct}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{punct}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{punct}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{punct}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{punct}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "punct",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Adlam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Adlam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Adlam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Adlam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Adlam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Adlam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Adlam",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Adlm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Adlm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Adlm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Adlm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Adlm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Adlm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Adlm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Aghb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Aghb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Aghb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Aghb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Aghb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Aghb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Aghb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Ahom}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Ahom}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Ahom}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Ahom}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Ahom}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Ahom}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ahom",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Anatolian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{sc=Anatolian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{sc=Anatolian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{sc=Anatolian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{sc=Anatolian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{sc=Anatolian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Anatolian_Hieroglyphs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Arabic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Arabic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Arabic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Arabic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Arabic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Arabic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Arabic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Arab}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Arab}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Arab}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Arab}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Arab}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Arab}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Arab",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Armenian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Armenian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Armenian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Armenian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Armenian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Armenian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Armenian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Armi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Armi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Armi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Armi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Armi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Armi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Armi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Armn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Armn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Armn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Armn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Armn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Armn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Armn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Avestan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Avestan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Avestan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Avestan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Avestan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Avestan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Avestan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Avst}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Avst}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Avst}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Avst}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Avst}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Avst}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Avst",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Balinese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Balinese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Balinese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Balinese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Balinese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Balinese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Balinese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Bali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Bali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Bali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Bali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Bali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Bali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bali",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Bamum}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Bamum}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Bamum}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Bamum}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Bamum}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Bamum}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bamum",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Bamu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Bamu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Bamu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Bamu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Bamu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Bamu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bamu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Bassa_Vah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{sc=Bassa_Vah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{sc=Bassa_Vah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{sc=Bassa_Vah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{sc=Bassa_Vah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{sc=Bassa_Vah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bassa_Vah",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Bass}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Bass}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Bass}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Bass}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Bass}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Bass}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bass",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Batak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Batak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Batak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Batak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Batak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Batak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Batak",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Batk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Batk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Batk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Batk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Batk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Batk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Batk",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Bengali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Bengali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Bengali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Bengali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Bengali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Bengali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bengali",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Beng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Beng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Beng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Beng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Beng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Beng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Beng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Bhaiksuki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{sc=Bhaiksuki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{sc=Bhaiksuki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{sc=Bhaiksuki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{sc=Bhaiksuki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{sc=Bhaiksuki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bhaiksuki",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Bhks}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Bhks}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Bhks}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Bhks}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Bhks}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Bhks}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bhks",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Bopomofo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Bopomofo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Bopomofo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Bopomofo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Bopomofo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Bopomofo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bopomofo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Bopo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Bopo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Bopo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Bopo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Bopo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Bopo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bopo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Brahmi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Brahmi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Brahmi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Brahmi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Brahmi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Brahmi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Brahmi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Brah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Brah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Brah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Brah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Brah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Brah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Brah",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Braille}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Braille}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Braille}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Braille}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Braille}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Braille}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Braille",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Brai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Brai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Brai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Brai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Brai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Brai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Brai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Buginese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Buginese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Buginese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Buginese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Buginese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Buginese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Buginese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Bugi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Bugi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Bugi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Bugi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Bugi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Bugi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bugi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Buhd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Buhd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Buhd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Buhd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Buhd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Buhd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Buhd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Buhid}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Buhid}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Buhid}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Buhid}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Buhid}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Buhid}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Buhid",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Cakm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Cakm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Cakm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Cakm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Cakm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Cakm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cakm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Canadian_Aboriginal}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{sc=Canadian_Aboriginal}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{sc=Canadian_Aboriginal}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{sc=Canadian_Aboriginal}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{sc=Canadian_Aboriginal}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{sc=Canadian_Aboriginal}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Canadian_Aboriginal",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Cans}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Cans}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Cans}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Cans}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Cans}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Cans}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cans",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Carian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Carian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Carian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Carian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Carian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Carian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Carian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Cari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Cari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Cari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Cari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Cari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Cari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Caucasian_Albanian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\P{sc=Caucasian_Albanian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\P{sc=Caucasian_Albanian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\P{sc=Caucasian_Albanian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\P{sc=Caucasian_Albanian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\P{sc=Caucasian_Albanian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Caucasian_Albanian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Chakma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Chakma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Chakma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Chakma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Chakma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Chakma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Chakma",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Cham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Cham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Cham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Cham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Cham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Cham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Cherokee}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Cherokee}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Cherokee}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Cherokee}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Cherokee}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Cherokee}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cherokee",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Cher}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Cher}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Cher}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Cher}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Cher}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Cher}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cher",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Chorasmian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{sc=Chorasmian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{sc=Chorasmian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{sc=Chorasmian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{sc=Chorasmian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{sc=Chorasmian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Chorasmian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Chrs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Chrs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Chrs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Chrs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Chrs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Chrs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Chrs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Common}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Common}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Common}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Common}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Common}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Common}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Common",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Coptic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Coptic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Coptic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Coptic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Coptic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Coptic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Coptic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Copt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Copt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Copt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Copt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Copt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Copt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Copt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Cpmn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Cpmn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Cpmn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Cpmn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Cpmn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Cpmn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cpmn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Cprt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Cprt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Cprt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Cprt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Cprt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Cprt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cprt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Cuneiform}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{sc=Cuneiform}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{sc=Cuneiform}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{sc=Cuneiform}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{sc=Cuneiform}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{sc=Cuneiform}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cuneiform",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Cypriot}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Cypriot}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Cypriot}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Cypriot}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Cypriot}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Cypriot}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cypriot",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Cypro_Minoan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{sc=Cypro_Minoan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{sc=Cypro_Minoan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{sc=Cypro_Minoan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{sc=Cypro_Minoan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{sc=Cypro_Minoan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cypro_Minoan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Cyrillic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Cyrillic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Cyrillic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Cyrillic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Cyrillic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Cyrillic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cyrillic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Cyrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Cyrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Cyrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Cyrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Cyrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Cyrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cyrl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Deseret}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Deseret}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Deseret}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Deseret}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Deseret}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Deseret}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Deseret",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Devanagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{sc=Devanagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{sc=Devanagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{sc=Devanagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{sc=Devanagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{sc=Devanagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Devanagari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Deva}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Deva}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Deva}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Deva}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Deva}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Deva}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Deva",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Diak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Diak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Diak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Diak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Diak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Diak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Diak",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Dives_Akuru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{sc=Dives_Akuru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{sc=Dives_Akuru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{sc=Dives_Akuru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{sc=Dives_Akuru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{sc=Dives_Akuru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Dives_Akuru",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Dogra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Dogra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Dogra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Dogra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Dogra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Dogra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Dogra",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Dogr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Dogr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Dogr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Dogr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Dogr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Dogr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Dogr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Dsrt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Dsrt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Dsrt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Dsrt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Dsrt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Dsrt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Dsrt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Duployan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Duployan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Duployan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Duployan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Duployan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Duployan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Duployan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Dupl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Dupl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Dupl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Dupl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Dupl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Dupl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Dupl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Egyptian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{sc=Egyptian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{sc=Egyptian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{sc=Egyptian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{sc=Egyptian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{sc=Egyptian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Egyptian_Hieroglyphs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Egyp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Egyp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Egyp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Egyp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Egyp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Egyp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Egyp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Elbasan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Elbasan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Elbasan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Elbasan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Elbasan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Elbasan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Elbasan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Elba}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Elba}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Elba}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Elba}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Elba}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Elba}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Elba",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Elymaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Elymaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Elymaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Elymaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Elymaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Elymaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Elymaic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Elym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Elym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Elym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Elym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Elym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Elym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Elym",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Ethiopic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Ethiopic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Ethiopic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Ethiopic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Ethiopic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Ethiopic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ethiopic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Ethi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Ethi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Ethi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Ethi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Ethi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Ethi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ethi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Georgian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Georgian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Georgian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Georgian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Georgian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Georgian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Georgian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Geor}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Geor}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Geor}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Geor}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Geor}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Geor}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Geor",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Glagolitic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{sc=Glagolitic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{sc=Glagolitic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{sc=Glagolitic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{sc=Glagolitic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{sc=Glagolitic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Glagolitic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Glag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Glag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Glag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Glag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Glag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Glag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Glag",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Gong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Gong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Gong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Gong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Gong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Gong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Gonm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Gonm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Gonm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Gonm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Gonm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Gonm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gonm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Gothic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Gothic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Gothic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Gothic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Gothic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Gothic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gothic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Goth}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Goth}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Goth}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Goth}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Goth}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Goth}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Goth",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Grantha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Grantha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Grantha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Grantha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Grantha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Grantha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Grantha",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Gran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Gran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Gran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Gran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Gran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Gran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gran",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Greek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Greek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Greek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Greek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Greek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Greek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Greek",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Grek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Grek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Grek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Grek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Grek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Grek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Grek",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Gujarati}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Gujarati}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Gujarati}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Gujarati}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Gujarati}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Gujarati}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gujarati",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Gujr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Gujr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Gujr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Gujr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Gujr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Gujr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gujr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Gunjala_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{sc=Gunjala_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{sc=Gunjala_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{sc=Gunjala_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{sc=Gunjala_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{sc=Gunjala_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gunjala_Gondi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Gurmukhi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Gurmukhi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Gurmukhi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Gurmukhi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Gurmukhi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Gurmukhi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gurmukhi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Guru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Guru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Guru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Guru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Guru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Guru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Guru",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hangul}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Hangul}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Hangul}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Hangul}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Hangul}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Hangul}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hangul",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Hang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Hang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Hang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Hang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Hang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hang",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hanifi_Rohingya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{sc=Hanifi_Rohingya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{sc=Hanifi_Rohingya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{sc=Hanifi_Rohingya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{sc=Hanifi_Rohingya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{sc=Hanifi_Rohingya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hanifi_Rohingya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Hani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Hani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Hani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Hani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Hani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hano}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Hano}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Hano}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Hano}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Hano}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Hano}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hano",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hanunoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Hanunoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Hanunoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Hanunoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Hanunoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Hanunoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hanunoo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Han}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{sc=Han}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{sc=Han}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{sc=Han}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{sc=Han}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{sc=Han}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Han",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hatran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Hatran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Hatran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Hatran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Hatran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Hatran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hatran",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hatr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Hatr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Hatr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Hatr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Hatr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Hatr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hatr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hebrew}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Hebrew}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Hebrew}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Hebrew}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Hebrew}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Hebrew}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hebrew",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hebr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Hebr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Hebr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Hebr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Hebr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Hebr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hebr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hiragana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Hiragana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Hiragana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Hiragana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Hiragana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Hiragana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hiragana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hira}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Hira}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Hira}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Hira}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Hira}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Hira}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hira",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hluw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Hluw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Hluw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Hluw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Hluw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Hluw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hluw",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hmng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Hmng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Hmng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Hmng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Hmng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Hmng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hmng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hmnp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Hmnp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Hmnp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Hmnp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Hmnp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Hmnp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hmnp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Hung}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Hung}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Hung}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Hung}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Hung}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Hung}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hung",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Imperial_Aramaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{sc=Imperial_Aramaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{sc=Imperial_Aramaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{sc=Imperial_Aramaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{sc=Imperial_Aramaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{sc=Imperial_Aramaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Imperial_Aramaic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Inherited}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{sc=Inherited}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{sc=Inherited}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{sc=Inherited}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{sc=Inherited}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{sc=Inherited}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Inherited",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Inscriptional_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{sc=Inscriptional_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{sc=Inscriptional_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{sc=Inscriptional_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{sc=Inscriptional_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{sc=Inscriptional_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Inscriptional_Pahlavi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Inscriptional_Parthian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{sc=Inscriptional_Parthian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{sc=Inscriptional_Parthian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{sc=Inscriptional_Parthian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{sc=Inscriptional_Parthian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{sc=Inscriptional_Parthian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Inscriptional_Parthian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Ital}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Ital}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Ital}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Ital}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Ital}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Ital}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ital",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Javanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Javanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Javanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Javanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Javanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Javanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Javanese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Java}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Java}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Java}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Java}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Java}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Java}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Java",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Kaithi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Kaithi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Kaithi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Kaithi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Kaithi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Kaithi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kaithi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Kali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Kali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Kali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Kali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Kali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Kali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kali",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Kana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Kana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Kana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Kana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Kana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Kana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Kannada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Kannada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Kannada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Kannada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Kannada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Kannada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kannada",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Katakana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Katakana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Katakana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Katakana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Katakana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Katakana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Katakana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Kawi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Kawi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Kawi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Kawi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Kawi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Kawi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kawi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Kayah_Li}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Kayah_Li}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Kayah_Li}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Kayah_Li}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Kayah_Li}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Kayah_Li}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kayah_Li",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Kharoshthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{sc=Kharoshthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{sc=Kharoshthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{sc=Kharoshthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{sc=Kharoshthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{sc=Kharoshthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kharoshthi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Khar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Khar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Khar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Khar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Khar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Khar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Khitan_Small_Script}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{sc=Khitan_Small_Script}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{sc=Khitan_Small_Script}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{sc=Khitan_Small_Script}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{sc=Khitan_Small_Script}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{sc=Khitan_Small_Script}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khitan_Small_Script",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Khmer}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Khmer}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Khmer}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Khmer}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Khmer}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Khmer}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khmer",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Khmr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Khmr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Khmr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Khmr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Khmr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Khmr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khmr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Khojki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Khojki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Khojki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Khojki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Khojki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Khojki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khojki",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Khoj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Khoj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Khoj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Khoj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Khoj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Khoj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khoj",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Khudawadi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{sc=Khudawadi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{sc=Khudawadi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{sc=Khudawadi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{sc=Khudawadi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{sc=Khudawadi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khudawadi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Kits}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Kits}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Kits}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Kits}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Kits}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Kits}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kits",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Knda}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Knda}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Knda}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Knda}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Knda}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Knda}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Knda",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Kthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Kthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Kthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Kthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Kthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Kthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kthi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Lana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Lana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Lana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Lana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Lana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Lana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Laoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Laoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Laoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Laoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Laoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Laoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Laoo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Lao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{sc=Lao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{sc=Lao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{sc=Lao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{sc=Lao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{sc=Lao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lao",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Latin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Latin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Latin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Latin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Latin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Latin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Latin",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Latn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Latn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Latn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Latn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Latn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Latn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Latn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Lepcha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Lepcha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Lepcha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Lepcha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Lepcha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Lepcha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lepcha",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Lepc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Lepc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Lepc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Lepc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Lepc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Lepc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lepc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Limbu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Limbu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Limbu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Limbu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Limbu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Limbu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Limbu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Limb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Limb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Limb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Limb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Limb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Limb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Limb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Lina}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Lina}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Lina}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Lina}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Lina}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Lina}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lina",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Linb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Linb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Linb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Linb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Linb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Linb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Linb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Linear_A}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Linear_A}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Linear_A}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Linear_A}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Linear_A}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Linear_A}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Linear_A",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Linear_B}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Linear_B}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Linear_B}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Linear_B}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Linear_B}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Linear_B}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Linear_B",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Lisu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Lisu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Lisu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Lisu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Lisu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Lisu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lisu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Lycian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Lycian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Lycian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Lycian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Lycian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Lycian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lycian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Lyci}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Lyci}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Lyci}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Lyci}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Lyci}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Lyci}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lyci",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Lydian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Lydian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Lydian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Lydian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Lydian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Lydian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lydian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Lydi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Lydi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Lydi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Lydi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Lydi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Lydi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lydi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mahajani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Mahajani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Mahajani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Mahajani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Mahajani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Mahajani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mahajani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mahj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Mahj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Mahj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Mahj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Mahj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Mahj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mahj",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Makasar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Makasar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Makasar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Makasar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Makasar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Makasar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Makasar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Maka}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Maka}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Maka}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Maka}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Maka}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Maka}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Maka",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Malayalam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{sc=Malayalam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{sc=Malayalam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{sc=Malayalam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{sc=Malayalam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{sc=Malayalam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Malayalam",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mandaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Mandaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Mandaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Mandaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Mandaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Mandaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mandaic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Mand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Mand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Mand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Mand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Mand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mand",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Manichaean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{sc=Manichaean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{sc=Manichaean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{sc=Manichaean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{sc=Manichaean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{sc=Manichaean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Manichaean",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Mani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Mani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Mani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Mani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Mani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Marchen}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Marchen}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Marchen}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Marchen}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Marchen}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Marchen}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Marchen",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Marc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Marc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Marc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Marc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Marc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Marc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Marc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Masaram_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{sc=Masaram_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{sc=Masaram_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{sc=Masaram_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{sc=Masaram_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{sc=Masaram_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Masaram_Gondi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Medefaidrin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{sc=Medefaidrin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{sc=Medefaidrin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{sc=Medefaidrin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{sc=Medefaidrin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{sc=Medefaidrin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Medefaidrin",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Medf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Medf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Medf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Medf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Medf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Medf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Medf",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Meetei_Mayek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{sc=Meetei_Mayek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{sc=Meetei_Mayek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{sc=Meetei_Mayek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{sc=Meetei_Mayek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{sc=Meetei_Mayek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Meetei_Mayek",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mende_Kikakui}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{sc=Mende_Kikakui}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{sc=Mende_Kikakui}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{sc=Mende_Kikakui}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{sc=Mende_Kikakui}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{sc=Mende_Kikakui}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mende_Kikakui",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mend}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Mend}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Mend}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Mend}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Mend}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Mend}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mend",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Merc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Merc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Merc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Merc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Merc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Merc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Merc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Meroitic_Cursive}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{sc=Meroitic_Cursive}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{sc=Meroitic_Cursive}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{sc=Meroitic_Cursive}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{sc=Meroitic_Cursive}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{sc=Meroitic_Cursive}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Meroitic_Cursive",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Meroitic_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{sc=Meroitic_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{sc=Meroitic_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{sc=Meroitic_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{sc=Meroitic_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{sc=Meroitic_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Meroitic_Hieroglyphs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mero}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Mero}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Mero}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Mero}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Mero}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Mero}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mero",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Miao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Miao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Miao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Miao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Miao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Miao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Miao",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mlym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Mlym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Mlym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Mlym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Mlym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Mlym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mlym",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Modi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Modi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Modi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Modi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Modi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Modi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Modi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mongolian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{sc=Mongolian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{sc=Mongolian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{sc=Mongolian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{sc=Mongolian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{sc=Mongolian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mongolian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Mong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Mong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Mong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Mong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Mong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mroo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Mroo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Mroo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Mroo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Mroo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Mroo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mroo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mro}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{sc=Mro}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{sc=Mro}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{sc=Mro}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{sc=Mro}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{sc=Mro}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mro",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mtei}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Mtei}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Mtei}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Mtei}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Mtei}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Mtei}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mtei",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Multani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Multani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Multani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Multani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Multani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Multani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Multani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mult}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Mult}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Mult}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Mult}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Mult}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Mult}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mult",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Myanmar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Myanmar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Myanmar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Myanmar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Myanmar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Myanmar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Myanmar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Mymr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Mymr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Mymr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Mymr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Mymr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Mymr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mymr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Nabataean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{sc=Nabataean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{sc=Nabataean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{sc=Nabataean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{sc=Nabataean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{sc=Nabataean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nabataean",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Nag_Mundari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{sc=Nag_Mundari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{sc=Nag_Mundari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{sc=Nag_Mundari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{sc=Nag_Mundari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{sc=Nag_Mundari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nag_Mundari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Nagm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Nagm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Nagm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Nagm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Nagm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Nagm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nagm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Nandinagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{sc=Nandinagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{sc=Nandinagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{sc=Nandinagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{sc=Nandinagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{sc=Nandinagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nandinagari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Nand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Nand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Nand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Nand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Nand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Nand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nand",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Narb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Narb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Narb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Narb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Narb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Narb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Narb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Nbat}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Nbat}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Nbat}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Nbat}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Nbat}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Nbat}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nbat",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=New_Tai_Lue}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{sc=New_Tai_Lue}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{sc=New_Tai_Lue}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{sc=New_Tai_Lue}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{sc=New_Tai_Lue}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{sc=New_Tai_Lue}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "New_Tai_Lue",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Newa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Newa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Newa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Newa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Newa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Newa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Newa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Nkoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Nkoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Nkoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Nkoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Nkoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Nkoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nkoo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Nko}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{sc=Nko}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{sc=Nko}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{sc=Nko}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{sc=Nko}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{sc=Nko}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nko",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Nshu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Nshu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Nshu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Nshu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Nshu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Nshu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nshu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Nushu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Nushu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Nushu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Nushu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Nushu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Nushu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nushu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Nyiakeng_Puachue_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{sc=Nyiakeng_Puachue_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{sc=Nyiakeng_Puachue_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{sc=Nyiakeng_Puachue_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{sc=Nyiakeng_Puachue_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{sc=Nyiakeng_Puachue_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nyiakeng_Puachue_Hmong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Ogam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Ogam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Ogam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Ogam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Ogam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Ogam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ogam",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Ogham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Ogham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Ogham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Ogham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Ogham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Ogham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ogham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Ol_Chiki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Ol_Chiki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Ol_Chiki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Ol_Chiki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Ol_Chiki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Ol_Chiki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ol_Chiki",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Olck}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Olck}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Olck}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Olck}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Olck}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Olck}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Olck",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Old_Hungarian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{sc=Old_Hungarian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{sc=Old_Hungarian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{sc=Old_Hungarian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{sc=Old_Hungarian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{sc=Old_Hungarian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Hungarian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Old_Italic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{sc=Old_Italic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{sc=Old_Italic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{sc=Old_Italic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{sc=Old_Italic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{sc=Old_Italic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Italic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Old_North_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{sc=Old_North_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{sc=Old_North_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{sc=Old_North_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{sc=Old_North_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{sc=Old_North_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_North_Arabian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Old_Permic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{sc=Old_Permic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{sc=Old_Permic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{sc=Old_Permic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{sc=Old_Permic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{sc=Old_Permic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Permic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Old_Persian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{sc=Old_Persian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{sc=Old_Persian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{sc=Old_Persian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{sc=Old_Persian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{sc=Old_Persian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Persian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Old_Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{sc=Old_Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{sc=Old_Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{sc=Old_Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{sc=Old_Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{sc=Old_Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Sogdian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Old_South_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{sc=Old_South_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{sc=Old_South_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{sc=Old_South_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{sc=Old_South_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{sc=Old_South_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_South_Arabian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Old_Turkic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{sc=Old_Turkic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{sc=Old_Turkic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{sc=Old_Turkic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{sc=Old_Turkic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{sc=Old_Turkic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Turkic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Old_Uyghur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{sc=Old_Uyghur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{sc=Old_Uyghur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{sc=Old_Uyghur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{sc=Old_Uyghur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{sc=Old_Uyghur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Uyghur",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Oriya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Oriya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Oriya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Oriya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Oriya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Oriya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Oriya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Orkh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Orkh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Orkh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Orkh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Orkh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Orkh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Orkh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Orya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Orya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Orya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Orya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Orya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Orya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Orya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Osage}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Osage}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Osage}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Osage}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Osage}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Osage}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Osage",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Osge}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Osge}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Osge}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Osge}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Osge}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Osge}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Osge",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Osmanya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Osmanya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Osmanya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Osmanya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Osmanya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Osmanya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Osmanya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Osma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Osma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Osma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Osma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Osma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Osma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Osma",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Ougr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Ougr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Ougr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Ougr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Ougr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Ougr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ougr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Pahawh_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{sc=Pahawh_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{sc=Pahawh_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{sc=Pahawh_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{sc=Pahawh_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{sc=Pahawh_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Pahawh_Hmong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Palmyrene}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{sc=Palmyrene}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{sc=Palmyrene}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{sc=Palmyrene}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{sc=Palmyrene}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{sc=Palmyrene}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Palmyrene",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Palm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Palm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Palm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Palm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Palm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Palm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Palm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Pau_Cin_Hau}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{sc=Pau_Cin_Hau}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{sc=Pau_Cin_Hau}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{sc=Pau_Cin_Hau}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{sc=Pau_Cin_Hau}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{sc=Pau_Cin_Hau}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Pau_Cin_Hau",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Pauc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Pauc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Pauc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Pauc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Pauc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Pauc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Pauc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Perm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Perm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Perm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Perm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Perm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Perm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Perm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Phags_Pa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Phags_Pa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Phags_Pa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Phags_Pa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Phags_Pa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Phags_Pa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Phags_Pa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Phag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Phag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Phag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Phag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Phag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Phag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Phag",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Phli}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Phli}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Phli}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Phli}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Phli}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Phli}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Phli",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Phlp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Phlp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Phlp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Phlp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Phlp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Phlp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Phlp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Phnx}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Phnx}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Phnx}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Phnx}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Phnx}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Phnx}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Phnx",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Phoenician}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{sc=Phoenician}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{sc=Phoenician}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{sc=Phoenician}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{sc=Phoenician}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{sc=Phoenician}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Phoenician",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Plrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Plrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Plrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Plrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Plrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Plrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Plrd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Prti}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Prti}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Prti}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Prti}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Prti}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Prti}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Prti",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Psalter_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\P{sc=Psalter_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\P{sc=Psalter_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\P{sc=Psalter_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\P{sc=Psalter_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\P{sc=Psalter_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Psalter_Pahlavi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Qaac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Qaac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Qaac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Qaac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Qaac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Qaac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Qaac",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Qaai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Qaai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Qaai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Qaai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Qaai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Qaai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Qaai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Rejang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Rejang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Rejang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Rejang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Rejang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Rejang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Rejang",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Rjng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Rjng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Rjng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Rjng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Rjng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Rjng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Rjng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Rohg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Rohg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Rohg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Rohg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Rohg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Rohg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Rohg",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Runic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Runic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Runic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Runic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Runic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Runic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Runic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Runr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Runr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Runr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Runr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Runr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Runr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Runr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Samaritan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{sc=Samaritan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{sc=Samaritan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{sc=Samaritan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{sc=Samaritan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{sc=Samaritan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Samaritan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Samr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Samr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Samr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Samr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Samr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Samr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Samr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sarb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Sarb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Sarb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Sarb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Sarb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Sarb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sarb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Saurashtra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{sc=Saurashtra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{sc=Saurashtra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{sc=Saurashtra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{sc=Saurashtra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{sc=Saurashtra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Saurashtra",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Saur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Saur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Saur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Saur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Saur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Saur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Saur",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sgnw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Sgnw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Sgnw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Sgnw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Sgnw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Sgnw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sgnw",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sharada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Sharada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Sharada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Sharada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Sharada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Sharada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sharada",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Shavian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Shavian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Shavian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Shavian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Shavian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Shavian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Shavian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Shaw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Shaw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Shaw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Shaw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Shaw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Shaw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Shaw",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Shrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Shrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Shrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Shrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Shrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Shrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Shrd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Siddham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Siddham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Siddham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Siddham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Siddham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Siddham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Siddham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sidd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Sidd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Sidd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Sidd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Sidd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Sidd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sidd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=SignWriting}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{sc=SignWriting}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{sc=SignWriting}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{sc=SignWriting}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{sc=SignWriting}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{sc=SignWriting}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "SignWriting",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sind}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Sind}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Sind}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Sind}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Sind}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Sind}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sind",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sinhala}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Sinhala}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Sinhala}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Sinhala}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Sinhala}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Sinhala}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sinhala",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Sinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Sinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Sinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Sinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Sinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sinh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sogdian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sogd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Sogd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Sogd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Sogd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Sogd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Sogd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sogd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sogo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Sogo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Sogo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Sogo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Sogo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Sogo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sogo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sora_Sompeng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{sc=Sora_Sompeng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{sc=Sora_Sompeng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{sc=Sora_Sompeng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{sc=Sora_Sompeng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{sc=Sora_Sompeng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sora_Sompeng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sora}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Sora}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Sora}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Sora}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Sora}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Sora}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sora",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Soyombo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Soyombo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Soyombo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Soyombo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Soyombo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Soyombo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Soyombo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Soyo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Soyo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Soyo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Soyo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Soyo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Soyo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Soyo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sundanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{sc=Sundanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{sc=Sundanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{sc=Sundanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{sc=Sundanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{sc=Sundanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sundanese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sund}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Sund}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Sund}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Sund}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Sund}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Sund}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sund",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Syloti_Nagri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{sc=Syloti_Nagri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{sc=Syloti_Nagri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{sc=Syloti_Nagri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{sc=Syloti_Nagri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{sc=Syloti_Nagri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Syloti_Nagri",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Sylo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Sylo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Sylo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Sylo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Sylo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Sylo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sylo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Syrc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Syrc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Syrc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Syrc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Syrc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Syrc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Syrc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Syriac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Syriac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Syriac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Syriac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Syriac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Syriac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Syriac",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tagalog}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Tagalog}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Tagalog}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Tagalog}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Tagalog}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Tagalog}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tagalog",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tagbanwa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Tagbanwa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Tagbanwa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Tagbanwa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Tagbanwa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Tagbanwa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tagbanwa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tagb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Tagb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Tagb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Tagb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Tagb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Tagb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tagb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tai_Le}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Tai_Le}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Tai_Le}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Tai_Le}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Tai_Le}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Tai_Le}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tai_Le",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tai_Tham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Tai_Tham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Tai_Tham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Tai_Tham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Tai_Tham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Tai_Tham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tai_Tham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tai_Viet}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Tai_Viet}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Tai_Viet}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Tai_Viet}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Tai_Viet}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Tai_Viet}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tai_Viet",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Takri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Takri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Takri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Takri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Takri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Takri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Takri",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Takr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Takr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Takr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Takr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Takr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Takr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Takr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tale}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Tale}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Tale}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Tale}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Tale}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Tale}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tale",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Talu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Talu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Talu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Talu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Talu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Talu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Talu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tamil}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{sc=Tamil}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{sc=Tamil}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{sc=Tamil}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{sc=Tamil}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{sc=Tamil}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tamil",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Taml}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Taml}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Taml}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Taml}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Taml}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Taml}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Taml",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tangsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Tangsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Tangsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Tangsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Tangsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Tangsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tangsa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tangut}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Tangut}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Tangut}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Tangut}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Tangut}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Tangut}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tangut",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Tang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Tang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Tang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Tang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Tang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tang",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tavt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Tavt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Tavt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Tavt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Tavt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Tavt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tavt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Telugu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Telugu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Telugu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Telugu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Telugu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Telugu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Telugu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Telu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Telu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Telu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Telu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Telu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Telu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Telu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tfng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Tfng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Tfng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Tfng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Tfng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Tfng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tfng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tglg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Tglg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Tglg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Tglg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Tglg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Tglg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tglg",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Thaana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Thaana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Thaana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Thaana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Thaana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Thaana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Thaana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Thaa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Thaa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Thaa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Thaa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Thaa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Thaa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Thaa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Thai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Thai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Thai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Thai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Thai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Thai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Thai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tibetan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Tibetan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Tibetan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Tibetan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Tibetan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Tibetan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tibetan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tibt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Tibt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Tibt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Tibt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Tibt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Tibt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tibt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tifinagh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Tifinagh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Tifinagh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Tifinagh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Tifinagh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Tifinagh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tifinagh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tirhuta}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{sc=Tirhuta}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{sc=Tirhuta}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{sc=Tirhuta}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{sc=Tirhuta}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{sc=Tirhuta}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tirhuta",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tirh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Tirh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Tirh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Tirh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Tirh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Tirh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tirh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Tnsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Tnsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Tnsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Tnsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Tnsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Tnsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tnsa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Toto}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Toto}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Toto}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Toto}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Toto}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Toto}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Toto",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Ugaritic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Ugaritic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Ugaritic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Ugaritic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Ugaritic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Ugaritic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ugaritic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Ugar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Ugar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Ugar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Ugar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Ugar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Ugar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ugar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Vaii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Vaii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Vaii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Vaii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Vaii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Vaii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Vaii",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Vai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{sc=Vai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{sc=Vai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{sc=Vai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{sc=Vai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{sc=Vai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Vai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Vithkuqi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{sc=Vithkuqi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{sc=Vithkuqi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{sc=Vithkuqi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{sc=Vithkuqi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{sc=Vithkuqi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Vithkuqi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Vith}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Vith}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Vith}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Vith}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Vith}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Vith}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Vith",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Wancho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Wancho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Wancho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Wancho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Wancho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Wancho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Wancho",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Warang_Citi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{sc=Warang_Citi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{sc=Warang_Citi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{sc=Warang_Citi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{sc=Warang_Citi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{sc=Warang_Citi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Warang_Citi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Wara}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Wara}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Wara}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Wara}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Wara}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Wara}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Wara",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Wcho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Wcho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Wcho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Wcho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Wcho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Wcho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Wcho",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Xpeo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Xpeo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Xpeo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Xpeo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Xpeo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Xpeo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Xpeo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Xsux}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Xsux}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Xsux}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Xsux}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Xsux}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Xsux}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Xsux",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Yezidi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{sc=Yezidi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{sc=Yezidi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{sc=Yezidi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{sc=Yezidi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{sc=Yezidi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Yezidi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Yezi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Yezi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Yezi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Yezi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Yezi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Yezi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Yezi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Yiii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Yiii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Yiii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Yiii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Yiii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Yiii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Yiii",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Yi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{sc=Yi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{sc=Yi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{sc=Yi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{sc=Yi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{sc=Yi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Yi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Zanabazar_Square}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{sc=Zanabazar_Square}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{sc=Zanabazar_Square}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{sc=Zanabazar_Square}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{sc=Zanabazar_Square}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{sc=Zanabazar_Square}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Zanabazar_Square",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Zanb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Zanb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Zanb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Zanb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Zanb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Zanb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Zanb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Zinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Zinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Zinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Zinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Zinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Zinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Zinh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{sc=Zyyy}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{sc=Zyyy}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{sc=Zyyy}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{sc=Zyyy}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{sc=Zyyy}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{sc=Zyyy}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Zyyy",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Adlam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Adlam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Adlam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Adlam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Adlam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Adlam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Adlam",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Adlm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Adlm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Adlm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Adlm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Adlm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Adlm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Adlm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Aghb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Aghb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Aghb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Aghb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Aghb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Aghb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Aghb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Ahom}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Ahom}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Ahom}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Ahom}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Ahom}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Ahom}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ahom",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Anatolian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{scx=Anatolian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{scx=Anatolian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{scx=Anatolian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{scx=Anatolian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{scx=Anatolian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Anatolian_Hieroglyphs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Arabic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Arabic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Arabic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Arabic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Arabic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Arabic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Arabic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Arab}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Arab}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Arab}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Arab}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Arab}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Arab}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Arab",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Armenian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Armenian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Armenian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Armenian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Armenian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Armenian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Armenian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Armi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Armi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Armi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Armi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Armi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Armi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Armi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Armn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Armn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Armn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Armn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Armn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Armn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Armn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Avestan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Avestan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Avestan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Avestan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Avestan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Avestan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Avestan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Avst}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Avst}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Avst}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Avst}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Avst}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Avst}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Avst",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Balinese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Balinese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Balinese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Balinese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Balinese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Balinese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Balinese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Bali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Bali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Bali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Bali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Bali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Bali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bali",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Bamum}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Bamum}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Bamum}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Bamum}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Bamum}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Bamum}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bamum",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Bamu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Bamu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Bamu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Bamu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Bamu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Bamu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bamu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Bassa_Vah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{scx=Bassa_Vah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{scx=Bassa_Vah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{scx=Bassa_Vah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{scx=Bassa_Vah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{scx=Bassa_Vah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bassa_Vah",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Bass}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Bass}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Bass}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Bass}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Bass}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Bass}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bass",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Batak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Batak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Batak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Batak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Batak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Batak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Batak",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Batk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Batk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Batk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Batk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Batk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Batk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Batk",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Bengali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Bengali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Bengali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Bengali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Bengali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Bengali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bengali",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Beng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Beng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Beng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Beng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Beng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Beng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Beng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Bhaiksuki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{scx=Bhaiksuki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{scx=Bhaiksuki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{scx=Bhaiksuki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{scx=Bhaiksuki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{scx=Bhaiksuki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bhaiksuki",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Bhks}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Bhks}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Bhks}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Bhks}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Bhks}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Bhks}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bhks",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Bopomofo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Bopomofo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Bopomofo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Bopomofo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Bopomofo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Bopomofo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bopomofo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Bopo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Bopo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Bopo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Bopo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Bopo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Bopo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bopo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Brahmi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Brahmi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Brahmi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Brahmi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Brahmi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Brahmi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Brahmi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Brah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Brah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Brah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Brah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Brah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Brah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Brah",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Braille}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Braille}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Braille}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Braille}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Braille}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Braille}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Braille",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Brai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Brai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Brai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Brai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Brai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Brai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Brai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Buginese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Buginese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Buginese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Buginese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Buginese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Buginese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Buginese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Bugi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Bugi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Bugi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Bugi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Bugi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Bugi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bugi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Buhd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Buhd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Buhd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Buhd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Buhd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Buhd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Buhd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Buhid}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Buhid}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Buhid}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Buhid}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Buhid}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Buhid}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Buhid",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Cakm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Cakm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Cakm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Cakm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Cakm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Cakm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cakm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Canadian_Aboriginal}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{scx=Canadian_Aboriginal}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{scx=Canadian_Aboriginal}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{scx=Canadian_Aboriginal}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{scx=Canadian_Aboriginal}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{scx=Canadian_Aboriginal}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Canadian_Aboriginal",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Cans}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Cans}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Cans}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Cans}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Cans}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Cans}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cans",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Carian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Carian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Carian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Carian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Carian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Carian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Carian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Cari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Cari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Cari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Cari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Cari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Cari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Caucasian_Albanian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\P{scx=Caucasian_Albanian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\P{scx=Caucasian_Albanian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\P{scx=Caucasian_Albanian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\P{scx=Caucasian_Albanian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\P{scx=Caucasian_Albanian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Caucasian_Albanian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Chakma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Chakma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Chakma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Chakma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Chakma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Chakma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Chakma",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Cham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Cham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Cham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Cham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Cham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Cham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Cherokee}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Cherokee}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Cherokee}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Cherokee}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Cherokee}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Cherokee}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cherokee",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Cher}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Cher}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Cher}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Cher}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Cher}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Cher}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cher",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Chorasmian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{scx=Chorasmian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{scx=Chorasmian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{scx=Chorasmian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{scx=Chorasmian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{scx=Chorasmian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Chorasmian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Chrs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Chrs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Chrs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Chrs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Chrs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Chrs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Chrs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Common}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Common}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Common}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Common}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Common}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Common}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Common",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Coptic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Coptic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Coptic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Coptic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Coptic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Coptic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Coptic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Copt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Copt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Copt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Copt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Copt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Copt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Copt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Cpmn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Cpmn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Cpmn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Cpmn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Cpmn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Cpmn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cpmn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Cprt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Cprt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Cprt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Cprt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Cprt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Cprt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cprt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Cuneiform}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{scx=Cuneiform}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{scx=Cuneiform}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{scx=Cuneiform}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{scx=Cuneiform}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{scx=Cuneiform}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cuneiform",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Cypriot}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Cypriot}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Cypriot}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Cypriot}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Cypriot}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Cypriot}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cypriot",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Cypro_Minoan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{scx=Cypro_Minoan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{scx=Cypro_Minoan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{scx=Cypro_Minoan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{scx=Cypro_Minoan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{scx=Cypro_Minoan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cypro_Minoan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Cyrillic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Cyrillic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Cyrillic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Cyrillic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Cyrillic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Cyrillic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cyrillic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Cyrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Cyrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Cyrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Cyrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Cyrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Cyrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cyrl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Deseret}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Deseret}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Deseret}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Deseret}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Deseret}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Deseret}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Deseret",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Devanagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{scx=Devanagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{scx=Devanagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{scx=Devanagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{scx=Devanagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{scx=Devanagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Devanagari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Deva}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Deva}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Deva}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Deva}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Deva}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Deva}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Deva",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Diak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Diak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Diak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Diak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Diak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Diak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Diak",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Dives_Akuru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{scx=Dives_Akuru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{scx=Dives_Akuru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{scx=Dives_Akuru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{scx=Dives_Akuru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{scx=Dives_Akuru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Dives_Akuru",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Dogra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Dogra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Dogra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Dogra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Dogra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Dogra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Dogra",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Dogr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Dogr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Dogr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Dogr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Dogr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Dogr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Dogr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Dsrt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Dsrt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Dsrt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Dsrt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Dsrt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Dsrt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Dsrt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Duployan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Duployan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Duployan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Duployan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Duployan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Duployan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Duployan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Dupl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Dupl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Dupl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Dupl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Dupl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Dupl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Dupl",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Egyptian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{scx=Egyptian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{scx=Egyptian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{scx=Egyptian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{scx=Egyptian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{scx=Egyptian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Egyptian_Hieroglyphs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Egyp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Egyp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Egyp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Egyp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Egyp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Egyp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Egyp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Elbasan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Elbasan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Elbasan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Elbasan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Elbasan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Elbasan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Elbasan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Elba}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Elba}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Elba}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Elba}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Elba}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Elba}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Elba",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Elymaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Elymaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Elymaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Elymaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Elymaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Elymaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Elymaic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Elym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Elym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Elym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Elym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Elym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Elym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Elym",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Ethiopic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Ethiopic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Ethiopic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Ethiopic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Ethiopic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Ethiopic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ethiopic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Ethi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Ethi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Ethi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Ethi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Ethi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Ethi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ethi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Georgian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Georgian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Georgian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Georgian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Georgian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Georgian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Georgian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Geor}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Geor}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Geor}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Geor}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Geor}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Geor}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Geor",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Glagolitic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{scx=Glagolitic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{scx=Glagolitic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{scx=Glagolitic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{scx=Glagolitic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{scx=Glagolitic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Glagolitic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Glag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Glag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Glag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Glag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Glag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Glag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Glag",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Gong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Gong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Gong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Gong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Gong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Gong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Gonm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Gonm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Gonm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Gonm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Gonm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Gonm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gonm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Gothic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Gothic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Gothic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Gothic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Gothic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Gothic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gothic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Goth}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Goth}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Goth}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Goth}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Goth}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Goth}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Goth",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Grantha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Grantha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Grantha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Grantha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Grantha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Grantha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Grantha",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Gran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Gran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Gran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Gran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Gran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Gran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gran",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Greek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Greek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Greek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Greek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Greek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Greek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Greek",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Grek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Grek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Grek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Grek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Grek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Grek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Grek",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Gujarati}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Gujarati}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Gujarati}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Gujarati}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Gujarati}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Gujarati}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gujarati",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Gujr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Gujr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Gujr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Gujr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Gujr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Gujr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gujr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Gunjala_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{scx=Gunjala_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{scx=Gunjala_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{scx=Gunjala_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{scx=Gunjala_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{scx=Gunjala_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gunjala_Gondi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Gurmukhi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Gurmukhi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Gurmukhi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Gurmukhi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Gurmukhi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Gurmukhi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gurmukhi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Guru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Guru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Guru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Guru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Guru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Guru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Guru",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hangul}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Hangul}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Hangul}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Hangul}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Hangul}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Hangul}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hangul",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Hang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Hang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Hang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Hang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Hang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hang",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hanifi_Rohingya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{scx=Hanifi_Rohingya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{scx=Hanifi_Rohingya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{scx=Hanifi_Rohingya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{scx=Hanifi_Rohingya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{scx=Hanifi_Rohingya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hanifi_Rohingya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Hani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Hani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Hani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Hani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Hani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hano}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Hano}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Hano}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Hano}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Hano}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Hano}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hano",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hanunoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Hanunoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Hanunoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Hanunoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Hanunoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Hanunoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hanunoo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Han}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{scx=Han}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{scx=Han}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{scx=Han}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{scx=Han}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{scx=Han}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Han",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hatran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Hatran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Hatran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Hatran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Hatran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Hatran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hatran",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hatr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Hatr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Hatr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Hatr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Hatr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Hatr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hatr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hebrew}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Hebrew}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Hebrew}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Hebrew}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Hebrew}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Hebrew}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hebrew",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hebr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Hebr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Hebr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Hebr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Hebr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Hebr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hebr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hiragana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Hiragana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Hiragana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Hiragana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Hiragana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Hiragana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hiragana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hira}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Hira}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Hira}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Hira}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Hira}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Hira}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hira",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hluw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Hluw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Hluw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Hluw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Hluw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Hluw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hluw",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hmng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Hmng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Hmng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Hmng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Hmng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Hmng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hmng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hmnp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Hmnp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Hmnp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Hmnp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Hmnp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Hmnp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hmnp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Hung}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Hung}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Hung}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Hung}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Hung}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Hung}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hung",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Imperial_Aramaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{scx=Imperial_Aramaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{scx=Imperial_Aramaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{scx=Imperial_Aramaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{scx=Imperial_Aramaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{scx=Imperial_Aramaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Imperial_Aramaic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Inherited}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{scx=Inherited}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{scx=Inherited}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{scx=Inherited}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{scx=Inherited}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{scx=Inherited}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Inherited",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Inscriptional_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\P{scx=Inscriptional_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\P{scx=Inscriptional_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\P{scx=Inscriptional_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\P{scx=Inscriptional_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\P{scx=Inscriptional_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Inscriptional_Pahlavi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Inscriptional_Parthian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{scx=Inscriptional_Parthian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{scx=Inscriptional_Parthian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{scx=Inscriptional_Parthian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{scx=Inscriptional_Parthian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{scx=Inscriptional_Parthian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Inscriptional_Parthian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Ital}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Ital}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Ital}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Ital}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Ital}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Ital}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ital",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Javanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Javanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Javanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Javanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Javanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Javanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Javanese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Java}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Java}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Java}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Java}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Java}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Java}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Java",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Kaithi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Kaithi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Kaithi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Kaithi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Kaithi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Kaithi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kaithi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Kali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Kali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Kali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Kali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Kali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Kali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kali",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Kana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Kana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Kana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Kana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Kana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Kana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Kannada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Kannada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Kannada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Kannada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Kannada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Kannada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kannada",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Katakana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Katakana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Katakana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Katakana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Katakana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Katakana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Katakana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Kawi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Kawi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Kawi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Kawi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Kawi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Kawi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kawi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Kayah_Li}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Kayah_Li}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Kayah_Li}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Kayah_Li}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Kayah_Li}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Kayah_Li}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kayah_Li",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Kharoshthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{scx=Kharoshthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{scx=Kharoshthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{scx=Kharoshthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{scx=Kharoshthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{scx=Kharoshthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kharoshthi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Khar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Khar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Khar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Khar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Khar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Khar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Khitan_Small_Script}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\P{scx=Khitan_Small_Script}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\P{scx=Khitan_Small_Script}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\P{scx=Khitan_Small_Script}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\P{scx=Khitan_Small_Script}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\P{scx=Khitan_Small_Script}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khitan_Small_Script",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Khmer}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Khmer}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Khmer}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Khmer}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Khmer}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Khmer}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khmer",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Khmr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Khmr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Khmr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Khmr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Khmr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Khmr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khmr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Khojki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Khojki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Khojki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Khojki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Khojki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Khojki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khojki",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Khoj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Khoj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Khoj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Khoj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Khoj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Khoj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khoj",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Khudawadi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{scx=Khudawadi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{scx=Khudawadi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{scx=Khudawadi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{scx=Khudawadi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{scx=Khudawadi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khudawadi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Kits}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Kits}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Kits}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Kits}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Kits}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Kits}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kits",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Knda}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Knda}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Knda}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Knda}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Knda}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Knda}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Knda",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Kthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Kthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Kthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Kthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Kthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Kthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kthi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Lana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Lana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Lana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Lana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Lana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Lana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Laoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Laoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Laoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Laoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Laoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Laoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Laoo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Lao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{scx=Lao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{scx=Lao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{scx=Lao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{scx=Lao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{scx=Lao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lao",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Latin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Latin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Latin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Latin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Latin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Latin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Latin",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Latn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Latn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Latn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Latn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Latn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Latn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Latn",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Lepcha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Lepcha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Lepcha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Lepcha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Lepcha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Lepcha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lepcha",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Lepc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Lepc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Lepc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Lepc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Lepc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Lepc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lepc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Limbu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Limbu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Limbu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Limbu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Limbu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Limbu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Limbu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Limb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Limb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Limb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Limb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Limb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Limb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Limb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Lina}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Lina}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Lina}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Lina}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Lina}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Lina}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lina",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Linb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Linb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Linb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Linb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Linb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Linb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Linb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Linear_A}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Linear_A}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Linear_A}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Linear_A}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Linear_A}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Linear_A}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Linear_A",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Linear_B}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Linear_B}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Linear_B}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Linear_B}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Linear_B}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Linear_B}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Linear_B",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Lisu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Lisu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Lisu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Lisu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Lisu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Lisu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lisu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Lycian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Lycian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Lycian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Lycian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Lycian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Lycian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lycian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Lyci}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Lyci}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Lyci}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Lyci}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Lyci}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Lyci}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lyci",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Lydian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Lydian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Lydian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Lydian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Lydian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Lydian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lydian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Lydi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Lydi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Lydi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Lydi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Lydi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Lydi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lydi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mahajani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Mahajani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Mahajani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Mahajani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Mahajani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Mahajani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mahajani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mahj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Mahj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Mahj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Mahj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Mahj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Mahj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mahj",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Makasar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Makasar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Makasar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Makasar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Makasar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Makasar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Makasar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Maka}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Maka}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Maka}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Maka}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Maka}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Maka}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Maka",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Malayalam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{scx=Malayalam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{scx=Malayalam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{scx=Malayalam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{scx=Malayalam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{scx=Malayalam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Malayalam",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mandaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Mandaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Mandaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Mandaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Mandaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Mandaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mandaic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Mand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Mand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Mand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Mand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Mand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mand",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Manichaean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{scx=Manichaean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{scx=Manichaean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{scx=Manichaean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{scx=Manichaean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{scx=Manichaean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Manichaean",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Mani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Mani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Mani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Mani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Mani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Marchen}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Marchen}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Marchen}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Marchen}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Marchen}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Marchen}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Marchen",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Marc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Marc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Marc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Marc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Marc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Marc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Marc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Masaram_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{scx=Masaram_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{scx=Masaram_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{scx=Masaram_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{scx=Masaram_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{scx=Masaram_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Masaram_Gondi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Medefaidrin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{scx=Medefaidrin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{scx=Medefaidrin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{scx=Medefaidrin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{scx=Medefaidrin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{scx=Medefaidrin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Medefaidrin",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Medf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Medf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Medf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Medf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Medf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Medf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Medf",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Meetei_Mayek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{scx=Meetei_Mayek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{scx=Meetei_Mayek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{scx=Meetei_Mayek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{scx=Meetei_Mayek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{scx=Meetei_Mayek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Meetei_Mayek",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mende_Kikakui}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{scx=Mende_Kikakui}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{scx=Mende_Kikakui}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{scx=Mende_Kikakui}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{scx=Mende_Kikakui}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{scx=Mende_Kikakui}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mende_Kikakui",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mend}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Mend}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Mend}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Mend}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Mend}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Mend}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mend",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Merc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Merc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Merc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Merc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Merc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Merc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Merc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Meroitic_Cursive}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{scx=Meroitic_Cursive}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{scx=Meroitic_Cursive}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{scx=Meroitic_Cursive}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{scx=Meroitic_Cursive}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{scx=Meroitic_Cursive}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Meroitic_Cursive",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Meroitic_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\P{scx=Meroitic_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\P{scx=Meroitic_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\P{scx=Meroitic_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\P{scx=Meroitic_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\P{scx=Meroitic_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Meroitic_Hieroglyphs",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mero}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Mero}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Mero}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Mero}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Mero}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Mero}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mero",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Miao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Miao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Miao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Miao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Miao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Miao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Miao",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mlym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Mlym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Mlym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Mlym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Mlym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Mlym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mlym",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Modi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Modi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Modi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Modi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Modi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Modi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Modi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mongolian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{scx=Mongolian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{scx=Mongolian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{scx=Mongolian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{scx=Mongolian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{scx=Mongolian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mongolian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Mong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Mong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Mong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Mong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Mong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mroo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Mroo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Mroo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Mroo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Mroo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Mroo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mroo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mro}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{scx=Mro}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{scx=Mro}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{scx=Mro}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{scx=Mro}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{scx=Mro}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mro",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mtei}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Mtei}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Mtei}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Mtei}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Mtei}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Mtei}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mtei",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Multani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Multani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Multani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Multani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Multani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Multani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Multani",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mult}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Mult}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Mult}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Mult}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Mult}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Mult}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mult",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Myanmar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Myanmar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Myanmar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Myanmar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Myanmar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Myanmar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Myanmar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Mymr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Mymr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Mymr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Mymr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Mymr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Mymr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mymr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Nabataean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{scx=Nabataean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{scx=Nabataean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{scx=Nabataean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{scx=Nabataean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{scx=Nabataean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nabataean",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Nag_Mundari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{scx=Nag_Mundari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{scx=Nag_Mundari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{scx=Nag_Mundari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{scx=Nag_Mundari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{scx=Nag_Mundari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nag_Mundari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Nagm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Nagm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Nagm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Nagm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Nagm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Nagm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nagm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Nandinagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{scx=Nandinagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{scx=Nandinagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{scx=Nandinagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{scx=Nandinagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{scx=Nandinagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nandinagari",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Nand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Nand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Nand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Nand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Nand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Nand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nand",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Narb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Narb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Narb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Narb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Narb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Narb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Narb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Nbat}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Nbat}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Nbat}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Nbat}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Nbat}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Nbat}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nbat",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=New_Tai_Lue}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{scx=New_Tai_Lue}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{scx=New_Tai_Lue}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{scx=New_Tai_Lue}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{scx=New_Tai_Lue}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{scx=New_Tai_Lue}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "New_Tai_Lue",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Newa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Newa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Newa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Newa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Newa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Newa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Newa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Nkoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Nkoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Nkoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Nkoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Nkoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Nkoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nkoo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Nko}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{scx=Nko}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{scx=Nko}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{scx=Nko}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{scx=Nko}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{scx=Nko}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nko",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Nshu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Nshu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Nshu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Nshu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Nshu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Nshu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nshu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Nushu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Nushu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Nushu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Nushu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Nushu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Nushu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nushu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Nyiakeng_Puachue_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\P{scx=Nyiakeng_Puachue_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\P{scx=Nyiakeng_Puachue_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\P{scx=Nyiakeng_Puachue_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\P{scx=Nyiakeng_Puachue_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\P{scx=Nyiakeng_Puachue_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nyiakeng_Puachue_Hmong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Ogam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Ogam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Ogam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Ogam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Ogam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Ogam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ogam",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Ogham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Ogham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Ogham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Ogham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Ogham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Ogham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ogham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Ol_Chiki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Ol_Chiki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Ol_Chiki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Ol_Chiki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Ol_Chiki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Ol_Chiki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ol_Chiki",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Olck}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Olck}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Olck}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Olck}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Olck}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Olck}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Olck",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Old_Hungarian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\P{scx=Old_Hungarian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\P{scx=Old_Hungarian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\P{scx=Old_Hungarian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\P{scx=Old_Hungarian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\P{scx=Old_Hungarian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Hungarian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Old_Italic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{scx=Old_Italic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{scx=Old_Italic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{scx=Old_Italic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{scx=Old_Italic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{scx=Old_Italic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Italic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Old_North_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\P{scx=Old_North_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\P{scx=Old_North_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\P{scx=Old_North_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\P{scx=Old_North_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\P{scx=Old_North_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_North_Arabian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Old_Permic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{scx=Old_Permic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{scx=Old_Permic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{scx=Old_Permic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{scx=Old_Permic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{scx=Old_Permic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Permic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Old_Persian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{scx=Old_Persian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{scx=Old_Persian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{scx=Old_Persian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{scx=Old_Persian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{scx=Old_Persian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Persian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Old_Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{scx=Old_Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{scx=Old_Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{scx=Old_Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{scx=Old_Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{scx=Old_Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Sogdian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Old_South_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\P{scx=Old_South_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\P{scx=Old_South_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\P{scx=Old_South_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\P{scx=Old_South_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\P{scx=Old_South_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_South_Arabian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Old_Turkic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{scx=Old_Turkic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{scx=Old_Turkic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{scx=Old_Turkic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{scx=Old_Turkic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{scx=Old_Turkic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Turkic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Old_Uyghur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{scx=Old_Uyghur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{scx=Old_Uyghur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{scx=Old_Uyghur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{scx=Old_Uyghur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{scx=Old_Uyghur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Uyghur",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Oriya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Oriya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Oriya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Oriya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Oriya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Oriya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Oriya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Orkh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Orkh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Orkh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Orkh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Orkh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Orkh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Orkh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Orya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Orya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Orya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Orya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Orya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Orya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Orya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Osage}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Osage}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Osage}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Osage}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Osage}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Osage}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Osage",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Osge}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Osge}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Osge}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Osge}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Osge}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Osge}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Osge",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Osmanya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Osmanya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Osmanya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Osmanya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Osmanya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Osmanya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Osmanya",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Osma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Osma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Osma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Osma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Osma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Osma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Osma",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Ougr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Ougr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Ougr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Ougr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Ougr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Ougr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ougr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Pahawh_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{scx=Pahawh_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{scx=Pahawh_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{scx=Pahawh_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{scx=Pahawh_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{scx=Pahawh_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Pahawh_Hmong",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Palmyrene}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{scx=Palmyrene}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{scx=Palmyrene}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{scx=Palmyrene}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{scx=Palmyrene}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{scx=Palmyrene}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Palmyrene",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Palm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Palm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Palm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Palm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Palm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Palm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Palm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Pau_Cin_Hau}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{scx=Pau_Cin_Hau}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{scx=Pau_Cin_Hau}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{scx=Pau_Cin_Hau}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{scx=Pau_Cin_Hau}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{scx=Pau_Cin_Hau}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Pau_Cin_Hau",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Pauc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Pauc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Pauc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Pauc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Pauc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Pauc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Pauc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Perm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Perm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Perm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Perm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Perm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Perm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Perm",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Phags_Pa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Phags_Pa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Phags_Pa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Phags_Pa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Phags_Pa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Phags_Pa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Phags_Pa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Phag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Phag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Phag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Phag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Phag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Phag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Phag",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Phli}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Phli}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Phli}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Phli}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Phli}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Phli}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Phli",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Phlp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Phlp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Phlp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Phlp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Phlp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Phlp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Phlp",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Phnx}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Phnx}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Phnx}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Phnx}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Phnx}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Phnx}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Phnx",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Phoenician}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{scx=Phoenician}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{scx=Phoenician}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{scx=Phoenician}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{scx=Phoenician}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{scx=Phoenician}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Phoenician",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Plrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Plrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Plrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Plrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Plrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Plrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Plrd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Prti}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Prti}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Prti}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Prti}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Prti}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Prti}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Prti",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Psalter_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\P{scx=Psalter_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\P{scx=Psalter_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\P{scx=Psalter_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\P{scx=Psalter_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\P{scx=Psalter_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Psalter_Pahlavi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Qaac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Qaac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Qaac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Qaac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Qaac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Qaac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Qaac",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Qaai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Qaai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Qaai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Qaai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Qaai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Qaai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Qaai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Rejang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Rejang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Rejang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Rejang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Rejang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Rejang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Rejang",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Rjng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Rjng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Rjng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Rjng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Rjng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Rjng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Rjng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Rohg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Rohg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Rohg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Rohg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Rohg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Rohg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Rohg",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Runic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Runic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Runic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Runic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Runic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Runic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Runic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Runr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Runr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Runr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Runr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Runr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Runr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Runr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Samaritan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{scx=Samaritan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{scx=Samaritan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{scx=Samaritan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{scx=Samaritan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{scx=Samaritan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Samaritan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Samr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Samr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Samr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Samr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Samr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Samr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Samr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sarb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Sarb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Sarb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Sarb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Sarb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Sarb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sarb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Saurashtra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\P{scx=Saurashtra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\P{scx=Saurashtra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\P{scx=Saurashtra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\P{scx=Saurashtra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\P{scx=Saurashtra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Saurashtra",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Saur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Saur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Saur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Saur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Saur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Saur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Saur",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sgnw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Sgnw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Sgnw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Sgnw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Sgnw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Sgnw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sgnw",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sharada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Sharada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Sharada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Sharada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Sharada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Sharada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sharada",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Shavian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Shavian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Shavian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Shavian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Shavian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Shavian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Shavian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Shaw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Shaw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Shaw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Shaw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Shaw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Shaw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Shaw",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Shrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Shrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Shrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Shrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Shrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Shrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Shrd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Siddham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Siddham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Siddham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Siddham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Siddham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Siddham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Siddham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sidd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Sidd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Sidd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Sidd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Sidd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Sidd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sidd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=SignWriting}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{scx=SignWriting}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{scx=SignWriting}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{scx=SignWriting}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{scx=SignWriting}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{scx=SignWriting}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "SignWriting",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sind}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Sind}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Sind}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Sind}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Sind}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Sind}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sind",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sinhala}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Sinhala}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Sinhala}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Sinhala}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Sinhala}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Sinhala}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sinhala",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Sinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Sinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Sinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Sinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Sinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sinh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sogdian",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sogd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Sogd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Sogd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Sogd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Sogd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Sogd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sogd",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sogo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Sogo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Sogo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Sogo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Sogo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Sogo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sogo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sora_Sompeng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{scx=Sora_Sompeng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{scx=Sora_Sompeng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{scx=Sora_Sompeng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{scx=Sora_Sompeng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{scx=Sora_Sompeng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sora_Sompeng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sora}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Sora}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Sora}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Sora}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Sora}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Sora}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sora",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Soyombo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Soyombo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Soyombo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Soyombo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Soyombo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Soyombo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Soyombo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Soyo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Soyo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Soyo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Soyo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Soyo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Soyo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Soyo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sundanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\P{scx=Sundanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\P{scx=Sundanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\P{scx=Sundanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\P{scx=Sundanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\P{scx=Sundanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sundanese",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sund}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Sund}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Sund}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Sund}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Sund}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Sund}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sund",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Syloti_Nagri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\P{scx=Syloti_Nagri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\P{scx=Syloti_Nagri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\P{scx=Syloti_Nagri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\P{scx=Syloti_Nagri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\P{scx=Syloti_Nagri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Syloti_Nagri",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Sylo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Sylo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Sylo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Sylo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Sylo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Sylo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sylo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Syrc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Syrc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Syrc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Syrc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Syrc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Syrc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Syrc",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Syriac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Syriac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Syriac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Syriac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Syriac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Syriac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Syriac",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tagalog}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Tagalog}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Tagalog}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Tagalog}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Tagalog}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Tagalog}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tagalog",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tagbanwa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Tagbanwa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Tagbanwa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Tagbanwa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Tagbanwa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Tagbanwa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tagbanwa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tagb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Tagb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Tagb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Tagb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Tagb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Tagb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tagb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tai_Le}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Tai_Le}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Tai_Le}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Tai_Le}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Tai_Le}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Tai_Le}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tai_Le",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tai_Tham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Tai_Tham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Tai_Tham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Tai_Tham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Tai_Tham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Tai_Tham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tai_Tham",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tai_Viet}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Tai_Viet}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Tai_Viet}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Tai_Viet}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Tai_Viet}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Tai_Viet}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tai_Viet",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Takri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Takri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Takri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Takri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Takri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Takri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Takri",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Takr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Takr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Takr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Takr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Takr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Takr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Takr",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tale}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Tale}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Tale}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Tale}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Tale}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Tale}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tale",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Talu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Talu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Talu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Talu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Talu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Talu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Talu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tamil}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\P{scx=Tamil}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\P{scx=Tamil}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\P{scx=Tamil}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\P{scx=Tamil}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\P{scx=Tamil}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tamil",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Taml}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Taml}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Taml}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Taml}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Taml}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Taml}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Taml",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tangsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Tangsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Tangsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Tangsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Tangsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Tangsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tangsa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tangut}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Tangut}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Tangut}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Tangut}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Tangut}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Tangut}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tangut",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Tang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Tang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Tang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Tang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Tang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tang",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tavt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Tavt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Tavt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Tavt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Tavt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Tavt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tavt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Telugu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Telugu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Telugu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Telugu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Telugu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Telugu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Telugu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Telu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Telu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Telu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Telu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Telu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Telu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Telu",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tfng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Tfng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Tfng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Tfng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Tfng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Tfng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tfng",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tglg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Tglg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Tglg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Tglg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Tglg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Tglg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tglg",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Thaana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Thaana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Thaana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Thaana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Thaana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Thaana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Thaana",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Thaa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Thaa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Thaa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Thaa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Thaa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Thaa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Thaa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Thai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Thai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Thai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Thai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Thai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Thai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Thai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tibetan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Tibetan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Tibetan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Tibetan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Tibetan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Tibetan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tibetan",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tibt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Tibt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Tibt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Tibt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Tibt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Tibt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tibt",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tifinagh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Tifinagh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Tifinagh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Tifinagh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Tifinagh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Tifinagh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tifinagh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tirhuta}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\P{scx=Tirhuta}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\P{scx=Tirhuta}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\P{scx=Tirhuta}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\P{scx=Tirhuta}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\P{scx=Tirhuta}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tirhuta",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tirh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Tirh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Tirh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Tirh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Tirh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Tirh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tirh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Tnsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Tnsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Tnsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Tnsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Tnsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Tnsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tnsa",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Toto}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Toto}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Toto}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Toto}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Toto}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Toto}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Toto",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Ugaritic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Ugaritic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Ugaritic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Ugaritic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Ugaritic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Ugaritic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ugaritic",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Ugar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Ugar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Ugar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Ugar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Ugar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Ugar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ugar",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Vaii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Vaii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Vaii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Vaii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Vaii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Vaii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Vaii",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Vai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\P{scx=Vai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\P{scx=Vai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\P{scx=Vai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\P{scx=Vai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\P{scx=Vai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Vai",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Vithkuqi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\P{scx=Vithkuqi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\P{scx=Vithkuqi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\P{scx=Vithkuqi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\P{scx=Vithkuqi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\P{scx=Vithkuqi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Vithkuqi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Vith}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Vith}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Vith}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Vith}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Vith}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Vith}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Vith",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Wancho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Wancho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Wancho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Wancho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Wancho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Wancho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Wancho",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Warang_Citi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\P{scx=Warang_Citi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\P{scx=Warang_Citi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\P{scx=Warang_Citi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\P{scx=Warang_Citi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\P{scx=Warang_Citi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Warang_Citi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Wara}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Wara}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Wara}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Wara}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Wara}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Wara}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Wara",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Wcho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Wcho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Wcho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Wcho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Wcho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Wcho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Wcho",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Xpeo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Xpeo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Xpeo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Xpeo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Xpeo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Xpeo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Xpeo",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Xsux}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Xsux}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Xsux}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Xsux}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Xsux}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Xsux}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Xsux",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Yezidi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\P{scx=Yezidi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\P{scx=Yezidi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\P{scx=Yezidi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\P{scx=Yezidi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\P{scx=Yezidi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Yezidi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Yezi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Yezi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Yezi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Yezi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Yezi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Yezi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Yezi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Yiii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Yiii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Yiii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Yiii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Yiii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Yiii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Yiii",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Yi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\P{scx=Yi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\P{scx=Yi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\P{scx=Yi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\P{scx=Yi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\P{scx=Yi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Yi",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Zanabazar_Square}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\P{scx=Zanabazar_Square}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\P{scx=Zanabazar_Square}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\P{scx=Zanabazar_Square}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\P{scx=Zanabazar_Square}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\P{scx=Zanabazar_Square}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Zanabazar_Square",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Zanb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Zanb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Zanb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Zanb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Zanb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Zanb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Zanb",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Zinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Zinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Zinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Zinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Zinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Zinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Zinh",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{scx=Zyyy}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\P{scx=Zyyy}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\P{scx=Zyyy}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\P{scx=Zyyy}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\P{scx=Zyyy}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\P{scx=Zyyy}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Zyyy",
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\P{space}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\P{space}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\P{space}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\P{space}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\P{space}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\P{space}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "space",
+                    "value": null,
+                    "negate": true
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{AHex}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{AHex}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{AHex}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{AHex}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{AHex}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{AHex}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "AHex",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{ASCII_Hex_Digit}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{ASCII_Hex_Digit}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{ASCII_Hex_Digit}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{ASCII_Hex_Digit}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{ASCII_Hex_Digit}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{ASCII_Hex_Digit}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "ASCII_Hex_Digit",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{ASCII}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{ASCII}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{ASCII}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{ASCII}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{ASCII}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{ASCII}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "ASCII",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Alphabetic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{Alphabetic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{Alphabetic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{Alphabetic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{Alphabetic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{Alphabetic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Alphabetic",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Alpha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{Alpha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{Alpha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{Alpha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{Alpha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{Alpha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Alpha",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Any}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\p{Any}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\p{Any}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\p{Any}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\p{Any}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\p{Any}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Any",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Assigned}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{Assigned}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{Assigned}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{Assigned}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{Assigned}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{Assigned}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Assigned",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Bidi_Control}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Bidi_Control}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Bidi_Control}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Bidi_Control}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Bidi_Control}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Bidi_Control}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Bidi_Control",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Bidi_C}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{Bidi_C}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{Bidi_C}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{Bidi_C}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{Bidi_C}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{Bidi_C}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Bidi_C",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Bidi_Mirrored}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Bidi_Mirrored}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Bidi_Mirrored}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Bidi_Mirrored}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Bidi_Mirrored}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Bidi_Mirrored}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Bidi_Mirrored",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Bidi_M}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{Bidi_M}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{Bidi_M}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{Bidi_M}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{Bidi_M}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{Bidi_M}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Bidi_M",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{CI}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{CI}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{CI}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{CI}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{CI}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{CI}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CI",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{CWCF}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{CWCF}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{CWCF}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{CWCF}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{CWCF}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{CWCF}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CWCF",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{CWCM}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{CWCM}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{CWCM}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{CWCM}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{CWCM}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{CWCM}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CWCM",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{CWKCF}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{CWKCF}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{CWKCF}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{CWKCF}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{CWKCF}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{CWKCF}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CWKCF",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{CWL}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\p{CWL}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\p{CWL}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\p{CWL}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\p{CWL}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\p{CWL}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CWL",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{CWT}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\p{CWT}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\p{CWT}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\p{CWT}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\p{CWT}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\p{CWT}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CWT",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{CWU}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\p{CWU}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\p{CWU}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\p{CWU}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\p{CWU}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\p{CWU}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "CWU",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Case_Ignorable}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Case_Ignorable}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Case_Ignorable}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Case_Ignorable}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Case_Ignorable}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Case_Ignorable}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Case_Ignorable",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Cased_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Cased_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Cased_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Cased_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Cased_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Cased_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cased_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Cased}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{Cased}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{Cased}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{Cased}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{Cased}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{Cased}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Cased",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Cc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Cc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Cc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Cc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Cc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Cc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Cf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Cf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Cf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Cf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Cf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Cf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cf",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Changes_When_Casefolded}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Changes_When_Casefolded}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Changes_When_Casefolded}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Changes_When_Casefolded}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Changes_When_Casefolded}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Changes_When_Casefolded}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Changes_When_Casefolded",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Changes_When_Casemapped}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Changes_When_Casemapped}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Changes_When_Casemapped}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Changes_When_Casemapped}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Changes_When_Casemapped}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Changes_When_Casemapped}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Changes_When_Casemapped",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Changes_When_Lowercased}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Changes_When_Lowercased}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Changes_When_Lowercased}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Changes_When_Lowercased}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Changes_When_Lowercased}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Changes_When_Lowercased}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Changes_When_Lowercased",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Changes_When_NFKC_Casefolded}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Changes_When_NFKC_Casefolded}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Changes_When_NFKC_Casefolded}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Changes_When_NFKC_Casefolded}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Changes_When_NFKC_Casefolded}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Changes_When_NFKC_Casefolded}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Changes_When_NFKC_Casefolded",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Changes_When_Titlecased}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Changes_When_Titlecased}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Changes_When_Titlecased}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Changes_When_Titlecased}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Changes_When_Titlecased}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Changes_When_Titlecased}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Changes_When_Titlecased",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Changes_When_Uppercased}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Changes_When_Uppercased}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Changes_When_Uppercased}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Changes_When_Uppercased}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Changes_When_Uppercased}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Changes_When_Uppercased}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Changes_When_Uppercased",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Close_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Close_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Close_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Close_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Close_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Close_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Close_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Cn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Cn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Cn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Cn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Cn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Cn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Combining_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Combining_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Combining_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Combining_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Combining_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Combining_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Combining_Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Connector_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\p{Connector_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\p{Connector_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\p{Connector_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\p{Connector_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\p{Connector_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Connector_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Control}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{Control}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{Control}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{Control}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{Control}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{Control}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Control",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Co}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Co}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Co}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Co}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Co}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Co}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Co",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Cs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Cs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Cs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Cs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Cs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Cs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Currency_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Currency_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Currency_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Currency_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Currency_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Currency_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Currency_Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{C}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\p{C}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\p{C}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\p{C}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\p{C}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\p{C}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "C",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{DI}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{DI}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{DI}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{DI}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{DI}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{DI}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "DI",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Dash_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Dash_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Dash_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Dash_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Dash_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Dash_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Dash_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Dash}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{Dash}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{Dash}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{Dash}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{Dash}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{Dash}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Dash",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Decimal_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Decimal_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Decimal_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Decimal_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Decimal_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Decimal_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Decimal_Number",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Default_Ignorable_Code_Point}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Default_Ignorable_Code_Point}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Default_Ignorable_Code_Point}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Default_Ignorable_Code_Point}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Default_Ignorable_Code_Point}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Default_Ignorable_Code_Point}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Default_Ignorable_Code_Point",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Deprecated}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{Deprecated}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{Deprecated}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{Deprecated}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{Deprecated}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{Deprecated}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Deprecated",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Dep}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\p{Dep}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\p{Dep}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\p{Dep}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\p{Dep}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\p{Dep}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Dep",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Diacritic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{Diacritic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{Diacritic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{Diacritic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{Diacritic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{Diacritic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Diacritic",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Dia}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\p{Dia}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\p{Dia}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\p{Dia}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\p{Dia}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\p{Dia}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Dia",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{EBase}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{EBase}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{EBase}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{EBase}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{EBase}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{EBase}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "EBase",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{EComp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{EComp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{EComp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{EComp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{EComp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{EComp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "EComp",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{EMod}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{EMod}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{EMod}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{EMod}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{EMod}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{EMod}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "EMod",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{EPres}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{EPres}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{EPres}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{EPres}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{EPres}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{EPres}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "EPres",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Emoji_Component}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Emoji_Component}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Emoji_Component}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Emoji_Component}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Emoji_Component}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Emoji_Component}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Emoji_Component",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Emoji_Modifier_Base}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{Emoji_Modifier_Base}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{Emoji_Modifier_Base}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{Emoji_Modifier_Base}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{Emoji_Modifier_Base}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{Emoji_Modifier_Base}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Emoji_Modifier_Base",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Emoji_Modifier}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Emoji_Modifier}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Emoji_Modifier}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Emoji_Modifier}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Emoji_Modifier}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Emoji_Modifier}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Emoji_Modifier",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Emoji_Presentation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{Emoji_Presentation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{Emoji_Presentation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{Emoji_Presentation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{Emoji_Presentation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{Emoji_Presentation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Emoji_Presentation",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Emoji}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{Emoji}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{Emoji}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{Emoji}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{Emoji}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{Emoji}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Emoji",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Enclosing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Enclosing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Enclosing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Enclosing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Enclosing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Enclosing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Enclosing_Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{ExtPict}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{ExtPict}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{ExtPict}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{ExtPict}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{ExtPict}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{ExtPict}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "ExtPict",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Extended_Pictographic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\p{Extended_Pictographic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\p{Extended_Pictographic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\p{Extended_Pictographic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\p{Extended_Pictographic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\p{Extended_Pictographic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Extended_Pictographic",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Extender}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{Extender}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{Extender}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{Extender}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{Extender}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{Extender}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Extender",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Ext}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\p{Ext}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\p{Ext}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\p{Ext}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\p{Ext}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\p{Ext}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Ext",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Final_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Final_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Final_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Final_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Final_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Final_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Final_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Format}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{Format}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{Format}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{Format}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{Format}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{Format}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Format",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Cased_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{General_Category=Cased_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{General_Category=Cased_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{General_Category=Cased_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{General_Category=Cased_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{General_Category=Cased_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cased_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Cc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Cc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Cc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Cc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Cc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Cc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Cf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Cf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Cf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Cf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Cf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Cf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cf",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Close_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/^\\p{General_Category=Close_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 42,
+          "raw": "^\\p{General_Category=Close_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 42,
+              "raw": "^\\p{General_Category=Close_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 41,
+                  "raw": "\\p{General_Category=Close_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 40,
+                    "raw": "\\p{General_Category=Close_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Close_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 41,
+                  "end": 42,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 43,
+          "end": 44,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Cn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Cn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Cn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Cn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Cn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Cn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Combining_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\p{General_Category=Combining_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\p{General_Category=Combining_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\p{General_Category=Combining_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\p{General_Category=Combining_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\p{General_Category=Combining_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Combining_Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Connector_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 48,
+        "raw": "/^\\p{General_Category=Connector_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 46,
+          "raw": "^\\p{General_Category=Connector_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 46,
+              "raw": "^\\p{General_Category=Connector_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 45,
+                  "raw": "\\p{General_Category=Connector_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 44,
+                    "raw": "\\p{General_Category=Connector_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Connector_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 45,
+                  "end": 46,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 47,
+          "end": 48,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Control}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{General_Category=Control}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{General_Category=Control}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{General_Category=Control}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{General_Category=Control}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{General_Category=Control}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Control",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Co}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Co}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Co}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Co}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Co}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Co}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Co",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Cs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Cs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Cs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Cs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Cs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Cs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Cs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Currency_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 42,
+        "raw": "/^\\p{General_Category=Currency_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "^\\p{General_Category=Currency_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "^\\p{General_Category=Currency_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 39,
+                  "raw": "\\p{General_Category=Currency_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 38,
+                    "raw": "\\p{General_Category=Currency_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Currency_Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 39,
+                  "end": 40,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 42,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=C}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{General_Category=C}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{General_Category=C}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{General_Category=C}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{General_Category=C}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{General_Category=C}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "C",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Dash_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\p{General_Category=Dash_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\p{General_Category=Dash_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\p{General_Category=Dash_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\p{General_Category=Dash_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\p{General_Category=Dash_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Dash_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Decimal_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\p{General_Category=Decimal_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\p{General_Category=Decimal_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\p{General_Category=Decimal_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\p{General_Category=Decimal_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\p{General_Category=Decimal_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Decimal_Number",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Enclosing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\p{General_Category=Enclosing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\p{General_Category=Enclosing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\p{General_Category=Enclosing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\p{General_Category=Enclosing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\p{General_Category=Enclosing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Enclosing_Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Final_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/^\\p{General_Category=Final_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 42,
+          "raw": "^\\p{General_Category=Final_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 42,
+              "raw": "^\\p{General_Category=Final_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 41,
+                  "raw": "\\p{General_Category=Final_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 40,
+                    "raw": "\\p{General_Category=Final_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Final_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 41,
+                  "end": 42,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 43,
+          "end": 44,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Format}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{General_Category=Format}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{General_Category=Format}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{General_Category=Format}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{General_Category=Format}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{General_Category=Format}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Format",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Initial_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 46,
+        "raw": "/^\\p{General_Category=Initial_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 44,
+          "raw": "^\\p{General_Category=Initial_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 44,
+              "raw": "^\\p{General_Category=Initial_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 43,
+                  "raw": "\\p{General_Category=Initial_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 42,
+                    "raw": "\\p{General_Category=Initial_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Initial_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 43,
+                  "end": 44,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 45,
+          "end": 46,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=LC}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=LC}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=LC}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=LC}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=LC}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=LC}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "LC",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Letter_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^\\p{General_Category=Letter_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^\\p{General_Category=Letter_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^\\p{General_Category=Letter_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "\\p{General_Category=Letter_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "\\p{General_Category=Letter_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Letter_Number",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{General_Category=Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{General_Category=Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{General_Category=Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{General_Category=Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{General_Category=Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Line_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\p{General_Category=Line_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\p{General_Category=Line_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\p{General_Category=Line_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\p{General_Category=Line_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\p{General_Category=Line_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Line_Separator",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Ll}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Ll}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Ll}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Ll}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Ll}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Ll}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Ll",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Lm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Lm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Lm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Lm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Lm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Lm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Lowercase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\p{General_Category=Lowercase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\p{General_Category=Lowercase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\p{General_Category=Lowercase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\p{General_Category=Lowercase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\p{General_Category=Lowercase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lowercase_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Lo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Lo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Lo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Lo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Lo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Lo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Lt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Lt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Lt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Lt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Lt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Lt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Lu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Lu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Lu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Lu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Lu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Lu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=L}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{General_Category=L}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{General_Category=L}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{General_Category=L}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{General_Category=L}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{General_Category=L}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "L",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\p{General_Category=Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\p{General_Category=Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\p{General_Category=Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\p{General_Category=Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\p{General_Category=Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Math_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{General_Category=Math_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{General_Category=Math_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{General_Category=Math_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{General_Category=Math_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{General_Category=Math_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Math_Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Mc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Mc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Mc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Mc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Mc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Mc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Mc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Me}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Me}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Me}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Me}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Me}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Me}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Me",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Mn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Mn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Mn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Mn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Mn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Mn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Mn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Modifier_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 42,
+        "raw": "/^\\p{General_Category=Modifier_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "^\\p{General_Category=Modifier_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "^\\p{General_Category=Modifier_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 39,
+                  "raw": "\\p{General_Category=Modifier_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 38,
+                    "raw": "\\p{General_Category=Modifier_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Modifier_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 39,
+                  "end": 40,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 42,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Modifier_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 42,
+        "raw": "/^\\p{General_Category=Modifier_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "^\\p{General_Category=Modifier_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "^\\p{General_Category=Modifier_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 39,
+                  "raw": "\\p{General_Category=Modifier_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 38,
+                    "raw": "\\p{General_Category=Modifier_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Modifier_Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 39,
+                  "end": 40,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 42,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=M}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{General_Category=M}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{General_Category=M}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{General_Category=M}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{General_Category=M}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{General_Category=M}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "M",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Nd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Nd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Nd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Nd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Nd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Nd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Nd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Nl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Nl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Nl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Nl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Nl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Nl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Nl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Nonspacing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 42,
+        "raw": "/^\\p{General_Category=Nonspacing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "^\\p{General_Category=Nonspacing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "^\\p{General_Category=Nonspacing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 39,
+                  "raw": "\\p{General_Category=Nonspacing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 38,
+                    "raw": "\\p{General_Category=Nonspacing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Nonspacing_Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 39,
+                  "end": 40,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 42,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=No}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=No}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=No}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=No}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=No}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=No}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "No",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{General_Category=Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{General_Category=Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{General_Category=Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{General_Category=Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{General_Category=Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Number",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=N}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{General_Category=N}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{General_Category=N}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{General_Category=N}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{General_Category=N}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{General_Category=N}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "N",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Open_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\p{General_Category=Open_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\p{General_Category=Open_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\p{General_Category=Open_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\p{General_Category=Open_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\p{General_Category=Open_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Open_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Other_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{General_Category=Other_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{General_Category=Other_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{General_Category=Other_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{General_Category=Other_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{General_Category=Other_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Other_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{General_Category=Other_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{General_Category=Other_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{General_Category=Other_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{General_Category=Other_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{General_Category=Other_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Number",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Other_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/^\\p{General_Category=Other_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 42,
+          "raw": "^\\p{General_Category=Other_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 42,
+              "raw": "^\\p{General_Category=Other_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 41,
+                  "raw": "\\p{General_Category=Other_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 40,
+                    "raw": "\\p{General_Category=Other_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 41,
+                  "end": 42,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 43,
+          "end": 44,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Other_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{General_Category=Other_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{General_Category=Other_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{General_Category=Other_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{General_Category=Other_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{General_Category=Other_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Other}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{General_Category=Other}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{General_Category=Other}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{General_Category=Other}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{General_Category=Other}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{General_Category=Other}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Paragraph_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 46,
+        "raw": "/^\\p{General_Category=Paragraph_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 44,
+          "raw": "^\\p{General_Category=Paragraph_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 44,
+              "raw": "^\\p{General_Category=Paragraph_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 43,
+                  "raw": "\\p{General_Category=Paragraph_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 42,
+                    "raw": "\\p{General_Category=Paragraph_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Paragraph_Separator",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 43,
+                  "end": 44,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 45,
+          "end": 46,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Pc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Pc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Pc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Pc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Pc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Pc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Pd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Pd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Pd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Pd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Pd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Pd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Pe}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Pe}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Pe}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Pe}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Pe}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Pe}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pe",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Pf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Pf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Pf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Pf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Pf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Pf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pf",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Pi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Pi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Pi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Pi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Pi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Pi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Po}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Po}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Po}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Po}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Po}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Po}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Po",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Private_Use}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{General_Category=Private_Use}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{General_Category=Private_Use}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{General_Category=Private_Use}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{General_Category=Private_Use}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{General_Category=Private_Use}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Private_Use",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Ps}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Ps}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Ps}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Ps}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Ps}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Ps}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Ps",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{General_Category=Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{General_Category=Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{General_Category=Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{General_Category=Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{General_Category=Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=P}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{General_Category=P}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{General_Category=P}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{General_Category=P}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{General_Category=P}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{General_Category=P}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "P",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Sc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Sc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Sc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Sc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Sc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Sc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Sc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{General_Category=Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{General_Category=Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{General_Category=Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{General_Category=Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{General_Category=Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Separator",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Sk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Sk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Sk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Sk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Sk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Sk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Sk",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Sm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Sm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Sm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Sm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Sm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Sm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Sm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=So}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=So}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=So}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=So}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=So}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=So}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "So",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Space_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 42,
+        "raw": "/^\\p{General_Category=Space_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 40,
+          "raw": "^\\p{General_Category=Space_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 40,
+              "raw": "^\\p{General_Category=Space_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 39,
+                  "raw": "\\p{General_Category=Space_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 38,
+                    "raw": "\\p{General_Category=Space_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Space_Separator",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 39,
+                  "end": 40,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 41,
+          "end": 42,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Spacing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{General_Category=Spacing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{General_Category=Spacing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{General_Category=Spacing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{General_Category=Spacing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{General_Category=Spacing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Spacing_Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Surrogate}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{General_Category=Surrogate}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{General_Category=Surrogate}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{General_Category=Surrogate}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{General_Category=Surrogate}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{General_Category=Surrogate}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Surrogate",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{General_Category=Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{General_Category=Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{General_Category=Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{General_Category=Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{General_Category=Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=S}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{General_Category=S}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{General_Category=S}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{General_Category=S}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{General_Category=S}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{General_Category=S}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "S",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Titlecase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\p{General_Category=Titlecase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\p{General_Category=Titlecase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\p{General_Category=Titlecase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\p{General_Category=Titlecase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\p{General_Category=Titlecase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Titlecase_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Unassigned}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{General_Category=Unassigned}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{General_Category=Unassigned}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{General_Category=Unassigned}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{General_Category=Unassigned}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{General_Category=Unassigned}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Unassigned",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Uppercase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\p{General_Category=Uppercase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\p{General_Category=Uppercase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\p{General_Category=Uppercase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\p{General_Category=Uppercase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\p{General_Category=Uppercase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Uppercase_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Zl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Zl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Zl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Zl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Zl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Zl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Zl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Zp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Zp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Zp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Zp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Zp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Zp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Zp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Zs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{General_Category=Zs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{General_Category=Zs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{General_Category=Zs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{General_Category=Zs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{General_Category=Zs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Zs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=Z}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{General_Category=Z}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{General_Category=Z}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{General_Category=Z}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{General_Category=Z}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{General_Category=Z}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Z",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=cntrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{General_Category=cntrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{General_Category=cntrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{General_Category=cntrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{General_Category=cntrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{General_Category=cntrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "cntrl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=digit}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{General_Category=digit}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{General_Category=digit}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{General_Category=digit}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{General_Category=digit}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{General_Category=digit}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "digit",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{General_Category=punct}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{General_Category=punct}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{General_Category=punct}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{General_Category=punct}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{General_Category=punct}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{General_Category=punct}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "punct",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Gr_Base}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{Gr_Base}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{Gr_Base}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{Gr_Base}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{Gr_Base}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{Gr_Base}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Gr_Base",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Gr_Ext}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{Gr_Ext}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{Gr_Ext}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{Gr_Ext}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{Gr_Ext}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{Gr_Ext}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Gr_Ext",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Grapheme_Base}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Grapheme_Base}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Grapheme_Base}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Grapheme_Base}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Grapheme_Base}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Grapheme_Base}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Grapheme_Base",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Grapheme_Extend}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Grapheme_Extend}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Grapheme_Extend}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Grapheme_Extend}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Grapheme_Extend}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Grapheme_Extend}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Grapheme_Extend",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Hex_Digit}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{Hex_Digit}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{Hex_Digit}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{Hex_Digit}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{Hex_Digit}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{Hex_Digit}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Hex_Digit",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Hex}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\p{Hex}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\p{Hex}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\p{Hex}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\p{Hex}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\p{Hex}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Hex",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{IDC}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\p{IDC}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\p{IDC}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\p{IDC}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\p{IDC}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\p{IDC}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "IDC",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{IDSB}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{IDSB}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{IDSB}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{IDSB}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{IDSB}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{IDSB}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "IDSB",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{IDST}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{IDST}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{IDST}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{IDST}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{IDST}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{IDST}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "IDST",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{IDS_Binary_Operator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{IDS_Binary_Operator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{IDS_Binary_Operator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{IDS_Binary_Operator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{IDS_Binary_Operator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{IDS_Binary_Operator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "IDS_Binary_Operator",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{IDS_Trinary_Operator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{IDS_Trinary_Operator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{IDS_Trinary_Operator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{IDS_Trinary_Operator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{IDS_Trinary_Operator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{IDS_Trinary_Operator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "IDS_Trinary_Operator",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{IDS}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\p{IDS}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\p{IDS}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\p{IDS}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\p{IDS}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\p{IDS}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "IDS",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{ID_Continue}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{ID_Continue}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{ID_Continue}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{ID_Continue}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{ID_Continue}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{ID_Continue}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "ID_Continue",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{ID_Start}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{ID_Start}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{ID_Start}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{ID_Start}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{ID_Start}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{ID_Start}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "ID_Start",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Ideographic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Ideographic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Ideographic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Ideographic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Ideographic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Ideographic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Ideographic",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Ideo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{Ideo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{Ideo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{Ideo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{Ideo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{Ideo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Ideo",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Initial_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{Initial_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{Initial_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{Initial_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{Initial_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{Initial_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Initial_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Join_Control}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Join_Control}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Join_Control}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Join_Control}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Join_Control}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Join_Control}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Join_Control",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Join_C}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{Join_C}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{Join_C}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{Join_C}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{Join_C}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{Join_C}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Join_C",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{LC}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{LC}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{LC}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{LC}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{LC}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{LC}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "LC",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{LOE}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^\\p{LOE}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^\\p{LOE}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^\\p{LOE}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "\\p{LOE}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "\\p{LOE}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "LOE",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Letter_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Letter_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Letter_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Letter_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Letter_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Letter_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Letter_Number",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Line_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Line_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Line_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Line_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Line_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Line_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Line_Separator",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Ll}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Ll}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Ll}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Ll}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Ll}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Ll}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Ll",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Lm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Lm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Lm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Lm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Lm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Lm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Logical_Order_Exception}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Logical_Order_Exception}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Logical_Order_Exception}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Logical_Order_Exception}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Logical_Order_Exception}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Logical_Order_Exception}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Logical_Order_Exception",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Lowercase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Lowercase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Lowercase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Lowercase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Lowercase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Lowercase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lowercase_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Lowercase}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{Lowercase}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{Lowercase}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{Lowercase}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{Lowercase}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{Lowercase}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Lowercase",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Lower}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{Lower}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{Lower}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{Lower}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{Lower}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{Lower}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Lower",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Lo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Lo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Lo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Lo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Lo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Lo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Lt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Lt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Lt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Lt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Lt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Lt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Lu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Lu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Lu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Lu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Lu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Lu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Lu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{L}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\p{L}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\p{L}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\p{L}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\p{L}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\p{L}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "L",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Math_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Math_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Math_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Math_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Math_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Math_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Math_Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Math}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{Math}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{Math}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{Math}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{Math}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{Math}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Math",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Mc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Mc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Mc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Mc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Mc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Mc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Mc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Me}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Me}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Me}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Me}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Me}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Me}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Me",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Mn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Mn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Mn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Mn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Mn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Mn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Mn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Modifier_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Modifier_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Modifier_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Modifier_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Modifier_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Modifier_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Modifier_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Modifier_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Modifier_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Modifier_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Modifier_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Modifier_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Modifier_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Modifier_Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{M}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\p{M}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\p{M}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\p{M}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\p{M}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\p{M}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "M",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{NChar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{NChar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{NChar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{NChar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{NChar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{NChar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "NChar",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Nd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Nd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Nd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Nd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Nd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Nd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Nd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Nl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Nl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Nl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Nl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Nl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Nl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Nl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Noncharacter_Code_Point}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Noncharacter_Code_Point}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Noncharacter_Code_Point}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Noncharacter_Code_Point}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Noncharacter_Code_Point}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Noncharacter_Code_Point}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Noncharacter_Code_Point",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Nonspacing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Nonspacing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Nonspacing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Nonspacing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Nonspacing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Nonspacing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Nonspacing_Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{No}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{No}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{No}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{No}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{No}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{No}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "No",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Number",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{N}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\p{N}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\p{N}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\p{N}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\p{N}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\p{N}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "N",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Open_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Open_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Open_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Open_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Open_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Open_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Open_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Other_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Other_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Other_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Other_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Other_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Other_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Other_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Other_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Other_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Other_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Other_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Other_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Number",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Other_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Other_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Other_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Other_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Other_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Other_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Other_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Other_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Other_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Other_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Other_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Other_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other_Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Other}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{Other}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{Other}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{Other}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{Other}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{Other}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Other",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Paragraph_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{Paragraph_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{Paragraph_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{Paragraph_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{Paragraph_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{Paragraph_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Paragraph_Separator",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Pat_Syn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{Pat_Syn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{Pat_Syn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{Pat_Syn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{Pat_Syn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{Pat_Syn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Pat_Syn",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Pat_WS}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{Pat_WS}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{Pat_WS}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{Pat_WS}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{Pat_WS}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{Pat_WS}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Pat_WS",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Pattern_Syntax}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Pattern_Syntax}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Pattern_Syntax}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Pattern_Syntax}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Pattern_Syntax}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Pattern_Syntax}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Pattern_Syntax",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Pattern_White_Space}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{Pattern_White_Space}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{Pattern_White_Space}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{Pattern_White_Space}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{Pattern_White_Space}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{Pattern_White_Space}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Pattern_White_Space",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Pc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Pc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Pc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Pc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Pc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Pc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Pd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Pd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Pd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Pd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Pd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Pd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Pe}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Pe}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Pe}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Pe}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Pe}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Pe}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pe",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Pf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Pf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Pf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Pf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Pf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Pf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pf",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Pi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Pi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Pi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Pi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Pi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Pi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Pi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Po}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Po}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Po}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Po}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Po}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Po}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Po",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Private_Use}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Private_Use}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Private_Use}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Private_Use}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Private_Use}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Private_Use}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Private_Use",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Ps}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Ps}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Ps}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Ps}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Ps}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Ps}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Ps",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{P}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\p{P}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\p{P}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\p{P}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\p{P}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\p{P}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "P",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{QMark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{QMark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{QMark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{QMark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{QMark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{QMark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "QMark",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Quotation_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Quotation_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Quotation_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Quotation_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Quotation_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Quotation_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Quotation_Mark",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{RI}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{RI}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{RI}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{RI}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{RI}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{RI}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "RI",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Radical}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{Radical}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{Radical}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{Radical}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{Radical}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{Radical}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Radical",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Regional_Indicator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{Regional_Indicator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{Regional_Indicator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{Regional_Indicator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{Regional_Indicator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{Regional_Indicator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Regional_Indicator",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{SD}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{SD}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{SD}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{SD}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{SD}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{SD}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "SD",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{STerm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{STerm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{STerm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{STerm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{STerm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{STerm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "STerm",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Adlam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Adlam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Adlam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Adlam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Adlam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Adlam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Adlam",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Adlm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Adlm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Adlm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Adlm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Adlm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Adlm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Adlm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Aghb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Aghb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Aghb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Aghb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Aghb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Aghb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Aghb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Ahom}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Ahom}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Ahom}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Ahom}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Ahom}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Ahom}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ahom",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Anatolian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Script=Anatolian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Script=Anatolian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Script=Anatolian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Script=Anatolian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Script=Anatolian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Anatolian_Hieroglyphs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Arabic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Arabic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Arabic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Arabic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Arabic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Arabic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Arabic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Arab}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Arab}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Arab}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Arab}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Arab}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Arab}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Arab",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Armenian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Armenian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Armenian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Armenian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Armenian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Armenian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Armenian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Armi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Armi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Armi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Armi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Armi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Armi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Armi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Armn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Armn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Armn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Armn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Armn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Armn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Armn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Avestan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Avestan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Avestan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Avestan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Avestan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Avestan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Avestan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Avst}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Avst}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Avst}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Avst}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Avst}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Avst}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Avst",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Balinese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Balinese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Balinese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Balinese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Balinese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Balinese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Balinese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Bali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Bali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Bali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Bali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Bali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Bali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bali",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Bamum}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Bamum}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Bamum}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Bamum}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Bamum}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Bamum}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bamum",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Bamu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Bamu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Bamu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Bamu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Bamu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Bamu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bamu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Bassa_Vah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Script=Bassa_Vah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Script=Bassa_Vah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Script=Bassa_Vah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Script=Bassa_Vah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Script=Bassa_Vah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bassa_Vah",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Bass}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Bass}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Bass}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Bass}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Bass}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Bass}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bass",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Batak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Batak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Batak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Batak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Batak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Batak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Batak",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Batk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Batk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Batk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Batk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Batk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Batk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Batk",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Bengali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Bengali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Bengali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Bengali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Bengali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Bengali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bengali",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Beng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Beng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Beng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Beng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Beng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Beng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Beng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Bhaiksuki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Script=Bhaiksuki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Script=Bhaiksuki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Script=Bhaiksuki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Script=Bhaiksuki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Script=Bhaiksuki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bhaiksuki",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Bhks}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Bhks}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Bhks}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Bhks}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Bhks}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Bhks}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bhks",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Bopomofo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Bopomofo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Bopomofo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Bopomofo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Bopomofo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Bopomofo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bopomofo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Bopo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Bopo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Bopo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Bopo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Bopo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Bopo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bopo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Brahmi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Brahmi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Brahmi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Brahmi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Brahmi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Brahmi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Brahmi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Brah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Brah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Brah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Brah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Brah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Brah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Brah",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Braille}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Braille}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Braille}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Braille}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Braille}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Braille}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Braille",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Brai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Brai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Brai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Brai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Brai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Brai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Brai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Buginese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Buginese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Buginese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Buginese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Buginese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Buginese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Buginese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Bugi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Bugi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Bugi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Bugi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Bugi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Bugi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Bugi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Buhd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Buhd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Buhd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Buhd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Buhd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Buhd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Buhd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Buhid}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Buhid}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Buhid}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Buhid}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Buhid}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Buhid}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Buhid",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Cakm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Cakm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Cakm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Cakm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Cakm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Cakm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cakm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Canadian_Aboriginal}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script=Canadian_Aboriginal}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script=Canadian_Aboriginal}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script=Canadian_Aboriginal}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script=Canadian_Aboriginal}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script=Canadian_Aboriginal}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Canadian_Aboriginal",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Cans}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Cans}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Cans}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Cans}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Cans}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Cans}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cans",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Carian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Carian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Carian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Carian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Carian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Carian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Carian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Cari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Cari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Cari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Cari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Cari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Cari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Caucasian_Albanian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script=Caucasian_Albanian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script=Caucasian_Albanian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script=Caucasian_Albanian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script=Caucasian_Albanian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script=Caucasian_Albanian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Caucasian_Albanian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Chakma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Chakma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Chakma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Chakma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Chakma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Chakma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Chakma",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Cham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Cham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Cham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Cham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Cham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Cham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Cherokee}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Cherokee}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Cherokee}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Cherokee}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Cherokee}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Cherokee}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cherokee",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Cher}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Cher}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Cher}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Cher}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Cher}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Cher}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cher",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Chorasmian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Script=Chorasmian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Script=Chorasmian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Script=Chorasmian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Script=Chorasmian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Script=Chorasmian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Chorasmian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Chrs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Chrs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Chrs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Chrs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Chrs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Chrs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Chrs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Common}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Common}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Common}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Common}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Common}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Common}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Common",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Coptic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Coptic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Coptic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Coptic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Coptic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Coptic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Coptic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Copt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Copt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Copt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Copt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Copt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Copt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Copt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Cpmn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Cpmn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Cpmn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Cpmn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Cpmn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Cpmn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cpmn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Cprt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Cprt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Cprt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Cprt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Cprt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Cprt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cprt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Cuneiform}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Script=Cuneiform}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Script=Cuneiform}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Script=Cuneiform}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Script=Cuneiform}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Script=Cuneiform}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cuneiform",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Cypriot}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Cypriot}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Cypriot}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Cypriot}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Cypriot}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Cypriot}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cypriot",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Cypro_Minoan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{Script=Cypro_Minoan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{Script=Cypro_Minoan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{Script=Cypro_Minoan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{Script=Cypro_Minoan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{Script=Cypro_Minoan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cypro_Minoan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Cyrillic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Cyrillic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Cyrillic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Cyrillic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Cyrillic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Cyrillic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cyrillic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Cyrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Cyrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Cyrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Cyrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Cyrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Cyrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Cyrl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Deseret}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Deseret}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Deseret}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Deseret}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Deseret}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Deseret}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Deseret",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Devanagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Script=Devanagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Script=Devanagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Script=Devanagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Script=Devanagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Script=Devanagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Devanagari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Deva}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Deva}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Deva}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Deva}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Deva}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Deva}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Deva",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Diak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Diak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Diak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Diak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Diak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Diak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Diak",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Dives_Akuru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{Script=Dives_Akuru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{Script=Dives_Akuru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{Script=Dives_Akuru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{Script=Dives_Akuru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{Script=Dives_Akuru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Dives_Akuru",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Dogra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Dogra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Dogra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Dogra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Dogra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Dogra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Dogra",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Dogr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Dogr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Dogr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Dogr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Dogr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Dogr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Dogr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Dsrt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Dsrt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Dsrt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Dsrt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Dsrt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Dsrt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Dsrt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Duployan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Duployan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Duployan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Duployan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Duployan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Duployan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Duployan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Dupl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Dupl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Dupl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Dupl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Dupl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Dupl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Dupl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Egyptian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{Script=Egyptian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{Script=Egyptian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{Script=Egyptian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{Script=Egyptian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{Script=Egyptian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Egyptian_Hieroglyphs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Egyp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Egyp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Egyp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Egyp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Egyp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Egyp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Egyp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Elbasan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Elbasan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Elbasan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Elbasan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Elbasan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Elbasan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Elbasan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Elba}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Elba}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Elba}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Elba}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Elba}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Elba}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Elba",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Elymaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Elymaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Elymaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Elymaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Elymaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Elymaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Elymaic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Elym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Elym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Elym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Elym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Elym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Elym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Elym",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Ethiopic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Ethiopic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Ethiopic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Ethiopic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Ethiopic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Ethiopic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ethiopic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Ethi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Ethi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Ethi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Ethi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Ethi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Ethi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ethi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Georgian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Georgian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Georgian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Georgian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Georgian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Georgian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Georgian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Geor}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Geor}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Geor}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Geor}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Geor}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Geor}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Geor",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Glagolitic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Script=Glagolitic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Script=Glagolitic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Script=Glagolitic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Script=Glagolitic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Script=Glagolitic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Glagolitic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Glag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Glag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Glag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Glag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Glag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Glag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Glag",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Gong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Gong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Gong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Gong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Gong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Gong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Gonm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Gonm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Gonm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Gonm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Gonm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Gonm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gonm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Gothic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Gothic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Gothic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Gothic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Gothic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Gothic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gothic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Goth}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Goth}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Goth}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Goth}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Goth}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Goth}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Goth",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Grantha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Grantha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Grantha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Grantha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Grantha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Grantha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Grantha",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Gran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Gran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Gran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Gran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Gran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Gran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gran",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Greek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Greek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Greek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Greek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Greek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Greek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Greek",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Grek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Grek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Grek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Grek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Grek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Grek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Grek",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Gujarati}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Gujarati}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Gujarati}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Gujarati}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Gujarati}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Gujarati}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gujarati",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Gujr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Gujr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Gujr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Gujr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Gujr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Gujr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gujr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Gunjala_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{Script=Gunjala_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{Script=Gunjala_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{Script=Gunjala_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{Script=Gunjala_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{Script=Gunjala_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gunjala_Gondi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Gurmukhi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Gurmukhi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Gurmukhi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Gurmukhi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Gurmukhi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Gurmukhi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Gurmukhi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Guru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Guru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Guru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Guru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Guru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Guru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Guru",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hangul}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Hangul}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Hangul}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Hangul}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Hangul}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Hangul}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hangul",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Hang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Hang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Hang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Hang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Hang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hang",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hanifi_Rohingya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script=Hanifi_Rohingya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script=Hanifi_Rohingya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script=Hanifi_Rohingya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script=Hanifi_Rohingya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script=Hanifi_Rohingya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hanifi_Rohingya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Hani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Hani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Hani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Hani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Hani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hano}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Hano}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Hano}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Hano}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Hano}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Hano}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hano",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hanunoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Hanunoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Hanunoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Hanunoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Hanunoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Hanunoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hanunoo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Han}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{Script=Han}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{Script=Han}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{Script=Han}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{Script=Han}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{Script=Han}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Han",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hatran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Hatran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Hatran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Hatran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Hatran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Hatran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hatran",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hatr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Hatr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Hatr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Hatr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Hatr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Hatr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hatr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hebrew}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Hebrew}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Hebrew}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Hebrew}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Hebrew}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Hebrew}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hebrew",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hebr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Hebr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Hebr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Hebr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Hebr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Hebr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hebr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hiragana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Hiragana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Hiragana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Hiragana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Hiragana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Hiragana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hiragana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hira}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Hira}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Hira}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Hira}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Hira}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Hira}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hira",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hluw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Hluw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Hluw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Hluw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Hluw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Hluw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hluw",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hmng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Hmng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Hmng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Hmng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Hmng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Hmng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hmng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hmnp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Hmnp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Hmnp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Hmnp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Hmnp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Hmnp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hmnp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Hung}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Hung}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Hung}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Hung}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Hung}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Hung}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Hung",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Imperial_Aramaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script=Imperial_Aramaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script=Imperial_Aramaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script=Imperial_Aramaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script=Imperial_Aramaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script=Imperial_Aramaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Imperial_Aramaic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Inherited}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Script=Inherited}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Script=Inherited}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Script=Inherited}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Script=Inherited}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Script=Inherited}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Inherited",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Inscriptional_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Script=Inscriptional_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Script=Inscriptional_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Script=Inscriptional_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Script=Inscriptional_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Script=Inscriptional_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Inscriptional_Pahlavi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Inscriptional_Parthian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{Script=Inscriptional_Parthian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{Script=Inscriptional_Parthian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{Script=Inscriptional_Parthian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{Script=Inscriptional_Parthian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{Script=Inscriptional_Parthian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Inscriptional_Parthian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Ital}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Ital}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Ital}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Ital}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Ital}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Ital}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ital",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Javanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Javanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Javanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Javanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Javanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Javanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Javanese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Java}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Java}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Java}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Java}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Java}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Java}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Java",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Kaithi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Kaithi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Kaithi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Kaithi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Kaithi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Kaithi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kaithi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Kali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Kali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Kali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Kali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Kali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Kali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kali",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Kana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Kana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Kana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Kana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Kana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Kana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Kannada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Kannada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Kannada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Kannada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Kannada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Kannada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kannada",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Katakana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Katakana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Katakana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Katakana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Katakana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Katakana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Katakana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Kawi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Kawi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Kawi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Kawi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Kawi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Kawi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kawi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Kayah_Li}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Kayah_Li}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Kayah_Li}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Kayah_Li}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Kayah_Li}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Kayah_Li}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kayah_Li",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Kharoshthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Script=Kharoshthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Script=Kharoshthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Script=Kharoshthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Script=Kharoshthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Script=Kharoshthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kharoshthi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Khar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Khar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Khar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Khar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Khar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Khar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Khitan_Small_Script}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script=Khitan_Small_Script}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script=Khitan_Small_Script}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script=Khitan_Small_Script}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script=Khitan_Small_Script}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script=Khitan_Small_Script}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khitan_Small_Script",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Khmer}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Khmer}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Khmer}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Khmer}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Khmer}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Khmer}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khmer",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Khmr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Khmr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Khmr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Khmr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Khmr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Khmr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khmr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Khojki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Khojki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Khojki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Khojki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Khojki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Khojki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khojki",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Khoj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Khoj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Khoj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Khoj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Khoj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Khoj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khoj",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Khudawadi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Script=Khudawadi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Script=Khudawadi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Script=Khudawadi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Script=Khudawadi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Script=Khudawadi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Khudawadi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Kits}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Kits}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Kits}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Kits}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Kits}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Kits}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kits",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Knda}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Knda}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Knda}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Knda}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Knda}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Knda}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Knda",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Kthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Kthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Kthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Kthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Kthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Kthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Kthi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Lana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Lana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Lana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Lana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Lana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Lana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Laoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Laoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Laoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Laoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Laoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Laoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Laoo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Lao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{Script=Lao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{Script=Lao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{Script=Lao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{Script=Lao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{Script=Lao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lao",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Latin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Latin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Latin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Latin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Latin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Latin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Latin",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Latn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Latn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Latn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Latn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Latn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Latn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Latn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Lepcha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Lepcha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Lepcha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Lepcha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Lepcha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Lepcha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lepcha",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Lepc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Lepc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Lepc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Lepc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Lepc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Lepc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lepc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Limbu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Limbu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Limbu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Limbu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Limbu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Limbu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Limbu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Limb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Limb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Limb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Limb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Limb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Limb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Limb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Lina}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Lina}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Lina}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Lina}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Lina}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Lina}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lina",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Linb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Linb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Linb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Linb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Linb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Linb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Linb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Linear_A}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Linear_A}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Linear_A}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Linear_A}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Linear_A}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Linear_A}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Linear_A",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Linear_B}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Linear_B}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Linear_B}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Linear_B}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Linear_B}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Linear_B}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Linear_B",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Lisu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Lisu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Lisu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Lisu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Lisu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Lisu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lisu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Lycian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Lycian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Lycian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Lycian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Lycian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Lycian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lycian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Lyci}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Lyci}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Lyci}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Lyci}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Lyci}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Lyci}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lyci",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Lydian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Lydian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Lydian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Lydian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Lydian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Lydian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lydian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Lydi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Lydi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Lydi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Lydi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Lydi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Lydi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Lydi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mahajani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Mahajani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Mahajani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Mahajani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Mahajani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Mahajani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mahajani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mahj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Mahj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Mahj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Mahj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Mahj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Mahj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mahj",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Makasar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Makasar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Makasar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Makasar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Makasar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Makasar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Makasar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Maka}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Maka}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Maka}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Maka}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Maka}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Maka}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Maka",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Malayalam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Script=Malayalam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Script=Malayalam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Script=Malayalam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Script=Malayalam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Script=Malayalam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Malayalam",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mandaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Mandaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Mandaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Mandaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Mandaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Mandaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mandaic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Mand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Mand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Mand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Mand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Mand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mand",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Manichaean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Script=Manichaean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Script=Manichaean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Script=Manichaean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Script=Manichaean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Script=Manichaean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Manichaean",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Mani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Mani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Mani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Mani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Mani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Marchen}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Marchen}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Marchen}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Marchen}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Marchen}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Marchen}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Marchen",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Marc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Marc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Marc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Marc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Marc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Marc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Marc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Masaram_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{Script=Masaram_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{Script=Masaram_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{Script=Masaram_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{Script=Masaram_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{Script=Masaram_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Masaram_Gondi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Medefaidrin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{Script=Medefaidrin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{Script=Medefaidrin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{Script=Medefaidrin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{Script=Medefaidrin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{Script=Medefaidrin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Medefaidrin",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Medf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Medf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Medf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Medf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Medf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Medf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Medf",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Meetei_Mayek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{Script=Meetei_Mayek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{Script=Meetei_Mayek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{Script=Meetei_Mayek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{Script=Meetei_Mayek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{Script=Meetei_Mayek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Meetei_Mayek",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mende_Kikakui}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{Script=Mende_Kikakui}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{Script=Mende_Kikakui}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{Script=Mende_Kikakui}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{Script=Mende_Kikakui}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{Script=Mende_Kikakui}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mende_Kikakui",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mend}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Mend}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Mend}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Mend}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Mend}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Mend}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mend",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Merc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Merc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Merc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Merc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Merc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Merc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Merc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Meroitic_Cursive}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script=Meroitic_Cursive}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script=Meroitic_Cursive}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script=Meroitic_Cursive}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script=Meroitic_Cursive}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script=Meroitic_Cursive}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Meroitic_Cursive",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Meroitic_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{Script=Meroitic_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{Script=Meroitic_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{Script=Meroitic_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{Script=Meroitic_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{Script=Meroitic_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Meroitic_Hieroglyphs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mero}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Mero}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Mero}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Mero}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Mero}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Mero}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mero",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Miao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Miao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Miao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Miao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Miao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Miao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Miao",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mlym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Mlym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Mlym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Mlym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Mlym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Mlym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mlym",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Modi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Modi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Modi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Modi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Modi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Modi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Modi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mongolian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Script=Mongolian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Script=Mongolian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Script=Mongolian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Script=Mongolian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Script=Mongolian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mongolian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Mong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Mong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Mong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Mong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Mong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mroo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Mroo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Mroo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Mroo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Mroo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Mroo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mroo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mro}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{Script=Mro}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{Script=Mro}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{Script=Mro}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{Script=Mro}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{Script=Mro}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mro",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mtei}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Mtei}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Mtei}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Mtei}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Mtei}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Mtei}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mtei",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Multani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Multani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Multani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Multani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Multani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Multani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Multani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mult}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Mult}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Mult}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Mult}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Mult}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Mult}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mult",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Myanmar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Myanmar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Myanmar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Myanmar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Myanmar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Myanmar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Myanmar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Mymr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Mymr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Mymr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Mymr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Mymr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Mymr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Mymr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Nabataean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Script=Nabataean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Script=Nabataean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Script=Nabataean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Script=Nabataean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Script=Nabataean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nabataean",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Nag_Mundari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{Script=Nag_Mundari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{Script=Nag_Mundari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{Script=Nag_Mundari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{Script=Nag_Mundari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{Script=Nag_Mundari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nag_Mundari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Nagm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Nagm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Nagm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Nagm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Nagm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Nagm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nagm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Nandinagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{Script=Nandinagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{Script=Nandinagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{Script=Nandinagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{Script=Nandinagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{Script=Nandinagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nandinagari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Nand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Nand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Nand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Nand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Nand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Nand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nand",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Narb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Narb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Narb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Narb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Narb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Narb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Narb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Nbat}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Nbat}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Nbat}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Nbat}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Nbat}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Nbat}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nbat",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=New_Tai_Lue}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{Script=New_Tai_Lue}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{Script=New_Tai_Lue}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{Script=New_Tai_Lue}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{Script=New_Tai_Lue}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{Script=New_Tai_Lue}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "New_Tai_Lue",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Newa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Newa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Newa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Newa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Newa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Newa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Newa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Nkoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Nkoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Nkoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Nkoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Nkoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Nkoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nkoo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Nko}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{Script=Nko}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{Script=Nko}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{Script=Nko}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{Script=Nko}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{Script=Nko}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nko",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Nshu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Nshu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Nshu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Nshu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Nshu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Nshu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nshu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Nushu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Nushu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Nushu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Nushu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Nushu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Nushu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nushu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Nyiakeng_Puachue_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{Script=Nyiakeng_Puachue_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{Script=Nyiakeng_Puachue_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{Script=Nyiakeng_Puachue_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{Script=Nyiakeng_Puachue_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{Script=Nyiakeng_Puachue_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Nyiakeng_Puachue_Hmong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Ogam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Ogam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Ogam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Ogam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Ogam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Ogam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ogam",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Ogham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Ogham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Ogham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Ogham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Ogham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Ogham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ogham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Ol_Chiki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Ol_Chiki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Ol_Chiki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Ol_Chiki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Ol_Chiki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Ol_Chiki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ol_Chiki",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Olck}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Olck}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Olck}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Olck}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Olck}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Olck}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Olck",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Old_Hungarian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{Script=Old_Hungarian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{Script=Old_Hungarian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{Script=Old_Hungarian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{Script=Old_Hungarian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{Script=Old_Hungarian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Hungarian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Old_Italic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Script=Old_Italic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Script=Old_Italic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Script=Old_Italic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Script=Old_Italic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Script=Old_Italic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Italic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Old_North_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script=Old_North_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script=Old_North_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script=Old_North_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script=Old_North_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script=Old_North_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_North_Arabian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Old_Permic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Script=Old_Permic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Script=Old_Permic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Script=Old_Permic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Script=Old_Permic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Script=Old_Permic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Permic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Old_Persian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{Script=Old_Persian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{Script=Old_Persian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{Script=Old_Persian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{Script=Old_Persian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{Script=Old_Persian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Persian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Old_Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{Script=Old_Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{Script=Old_Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{Script=Old_Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{Script=Old_Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{Script=Old_Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Sogdian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Old_South_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script=Old_South_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script=Old_South_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script=Old_South_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script=Old_South_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script=Old_South_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_South_Arabian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Old_Turkic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Script=Old_Turkic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Script=Old_Turkic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Script=Old_Turkic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Script=Old_Turkic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Script=Old_Turkic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Turkic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Old_Uyghur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Script=Old_Uyghur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Script=Old_Uyghur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Script=Old_Uyghur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Script=Old_Uyghur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Script=Old_Uyghur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Old_Uyghur",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Oriya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Oriya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Oriya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Oriya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Oriya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Oriya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Oriya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Orkh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Orkh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Orkh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Orkh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Orkh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Orkh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Orkh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Orya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Orya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Orya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Orya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Orya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Orya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Orya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Osage}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Osage}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Osage}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Osage}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Osage}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Osage}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Osage",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Osge}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Osge}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Osge}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Osge}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Osge}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Osge}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Osge",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Osmanya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Osmanya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Osmanya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Osmanya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Osmanya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Osmanya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Osmanya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Osma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Osma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Osma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Osma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Osma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Osma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Osma",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Ougr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Ougr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Ougr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Ougr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Ougr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Ougr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ougr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Pahawh_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{Script=Pahawh_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{Script=Pahawh_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{Script=Pahawh_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{Script=Pahawh_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{Script=Pahawh_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Pahawh_Hmong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Palmyrene}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Script=Palmyrene}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Script=Palmyrene}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Script=Palmyrene}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Script=Palmyrene}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Script=Palmyrene}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Palmyrene",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Palm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Palm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Palm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Palm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Palm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Palm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Palm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Pau_Cin_Hau}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{Script=Pau_Cin_Hau}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{Script=Pau_Cin_Hau}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{Script=Pau_Cin_Hau}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{Script=Pau_Cin_Hau}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{Script=Pau_Cin_Hau}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Pau_Cin_Hau",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Pauc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Pauc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Pauc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Pauc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Pauc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Pauc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Pauc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Perm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Perm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Perm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Perm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Perm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Perm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Perm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Phags_Pa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Phags_Pa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Phags_Pa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Phags_Pa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Phags_Pa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Phags_Pa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Phags_Pa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Phag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Phag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Phag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Phag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Phag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Phag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Phag",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Phli}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Phli}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Phli}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Phli}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Phli}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Phli}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Phli",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Phlp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Phlp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Phlp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Phlp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Phlp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Phlp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Phlp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Phnx}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Phnx}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Phnx}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Phnx}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Phnx}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Phnx}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Phnx",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Phoenician}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Script=Phoenician}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Script=Phoenician}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Script=Phoenician}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Script=Phoenician}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Script=Phoenician}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Phoenician",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Plrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Plrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Plrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Plrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Plrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Plrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Plrd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Prti}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Prti}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Prti}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Prti}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Prti}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Prti}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Prti",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Psalter_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script=Psalter_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script=Psalter_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script=Psalter_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script=Psalter_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script=Psalter_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Psalter_Pahlavi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Qaac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Qaac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Qaac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Qaac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Qaac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Qaac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Qaac",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Qaai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Qaai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Qaai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Qaai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Qaai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Qaai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Qaai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Rejang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Rejang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Rejang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Rejang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Rejang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Rejang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Rejang",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Rjng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Rjng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Rjng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Rjng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Rjng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Rjng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Rjng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Rohg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Rohg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Rohg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Rohg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Rohg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Rohg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Rohg",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Runic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Runic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Runic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Runic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Runic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Runic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Runic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Runr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Runr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Runr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Runr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Runr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Runr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Runr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Samaritan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Script=Samaritan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Script=Samaritan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Script=Samaritan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Script=Samaritan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Script=Samaritan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Samaritan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Samr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Samr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Samr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Samr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Samr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Samr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Samr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sarb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Sarb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Sarb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Sarb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Sarb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Sarb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sarb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Saurashtra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Script=Saurashtra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Script=Saurashtra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Script=Saurashtra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Script=Saurashtra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Script=Saurashtra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Saurashtra",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Saur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Saur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Saur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Saur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Saur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Saur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Saur",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sgnw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Sgnw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Sgnw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Sgnw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Sgnw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Sgnw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sgnw",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sharada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Sharada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Sharada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Sharada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Sharada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Sharada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sharada",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Shavian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Shavian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Shavian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Shavian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Shavian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Shavian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Shavian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Shaw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Shaw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Shaw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Shaw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Shaw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Shaw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Shaw",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Shrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Shrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Shrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Shrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Shrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Shrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Shrd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Siddham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Siddham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Siddham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Siddham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Siddham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Siddham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Siddham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sidd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Sidd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Sidd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Sidd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Sidd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Sidd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sidd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=SignWriting}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{Script=SignWriting}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{Script=SignWriting}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{Script=SignWriting}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{Script=SignWriting}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{Script=SignWriting}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "SignWriting",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sind}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Sind}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Sind}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Sind}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Sind}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Sind}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sind",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sinhala}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Sinhala}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Sinhala}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Sinhala}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Sinhala}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Sinhala}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sinhala",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Sinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Sinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Sinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Sinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Sinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sinh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sogdian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sogd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Sogd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Sogd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Sogd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Sogd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Sogd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sogd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sogo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Sogo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Sogo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Sogo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Sogo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Sogo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sogo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sora_Sompeng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{Script=Sora_Sompeng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{Script=Sora_Sompeng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{Script=Sora_Sompeng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{Script=Sora_Sompeng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{Script=Sora_Sompeng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sora_Sompeng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sora}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Sora}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Sora}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Sora}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Sora}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Sora}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sora",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Soyombo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Soyombo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Soyombo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Soyombo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Soyombo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Soyombo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Soyombo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Soyo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Soyo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Soyo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Soyo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Soyo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Soyo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Soyo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sundanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Script=Sundanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Script=Sundanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Script=Sundanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Script=Sundanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Script=Sundanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sundanese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sund}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Sund}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Sund}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Sund}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Sund}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Sund}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sund",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Syloti_Nagri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{Script=Syloti_Nagri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{Script=Syloti_Nagri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{Script=Syloti_Nagri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{Script=Syloti_Nagri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{Script=Syloti_Nagri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Syloti_Nagri",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Sylo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Sylo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Sylo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Sylo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Sylo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Sylo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Sylo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Syrc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Syrc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Syrc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Syrc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Syrc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Syrc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Syrc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Syriac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Syriac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Syriac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Syriac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Syriac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Syriac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Syriac",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tagalog}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Tagalog}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Tagalog}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Tagalog}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Tagalog}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Tagalog}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tagalog",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tagbanwa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Tagbanwa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Tagbanwa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Tagbanwa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Tagbanwa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Tagbanwa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tagbanwa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tagb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Tagb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Tagb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Tagb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Tagb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Tagb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tagb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tai_Le}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Tai_Le}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Tai_Le}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Tai_Le}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Tai_Le}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Tai_Le}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tai_Le",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tai_Tham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Tai_Tham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Tai_Tham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Tai_Tham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Tai_Tham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Tai_Tham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tai_Tham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tai_Viet}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Tai_Viet}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Tai_Viet}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Tai_Viet}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Tai_Viet}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Tai_Viet}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tai_Viet",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Takri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Takri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Takri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Takri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Takri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Takri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Takri",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Takr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Takr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Takr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Takr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Takr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Takr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Takr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tale}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Tale}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Tale}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Tale}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Tale}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Tale}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tale",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Talu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Talu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Talu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Talu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Talu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Talu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Talu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tamil}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Script=Tamil}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Script=Tamil}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Script=Tamil}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Script=Tamil}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Script=Tamil}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tamil",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Taml}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Taml}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Taml}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Taml}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Taml}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Taml}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Taml",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tangsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Tangsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Tangsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Tangsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Tangsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Tangsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tangsa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tangut}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Tangut}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Tangut}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Tangut}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Tangut}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Tangut}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tangut",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Tang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Tang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Tang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Tang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Tang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tang",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tavt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Tavt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Tavt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Tavt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Tavt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Tavt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tavt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Telugu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Telugu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Telugu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Telugu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Telugu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Telugu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Telugu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Telu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Telu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Telu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Telu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Telu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Telu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Telu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tfng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Tfng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Tfng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Tfng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Tfng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Tfng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tfng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tglg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Tglg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Tglg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Tglg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Tglg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Tglg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tglg",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Thaana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Thaana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Thaana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Thaana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Thaana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Thaana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Thaana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Thaa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Thaa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Thaa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Thaa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Thaa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Thaa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Thaa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Thai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Thai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Thai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Thai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Thai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Thai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Thai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tibetan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Tibetan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Tibetan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Tibetan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Tibetan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Tibetan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tibetan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tibt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Tibt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Tibt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Tibt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Tibt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Tibt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tibt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tifinagh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Tifinagh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Tifinagh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Tifinagh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Tifinagh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Tifinagh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tifinagh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tirhuta}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{Script=Tirhuta}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{Script=Tirhuta}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{Script=Tirhuta}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{Script=Tirhuta}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{Script=Tirhuta}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tirhuta",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tirh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Tirh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Tirh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Tirh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Tirh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Tirh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tirh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Tnsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Tnsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Tnsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Tnsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Tnsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Tnsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Tnsa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Toto}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Toto}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Toto}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Toto}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Toto}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Toto}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Toto",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Ugaritic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Ugaritic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Ugaritic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Ugaritic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Ugaritic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Ugaritic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ugaritic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Ugar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Ugar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Ugar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Ugar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Ugar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Ugar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Ugar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Vaii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Vaii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Vaii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Vaii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Vaii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Vaii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Vaii",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Vai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{Script=Vai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{Script=Vai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{Script=Vai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{Script=Vai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{Script=Vai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Vai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Vithkuqi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Script=Vithkuqi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Script=Vithkuqi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Script=Vithkuqi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Script=Vithkuqi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Script=Vithkuqi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Vithkuqi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Vith}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Vith}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Vith}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Vith}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Vith}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Vith}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Vith",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Wancho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Wancho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Wancho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Wancho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Wancho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Wancho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Wancho",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Warang_Citi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{Script=Warang_Citi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{Script=Warang_Citi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{Script=Warang_Citi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{Script=Warang_Citi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{Script=Warang_Citi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Warang_Citi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Wara}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Wara}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Wara}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Wara}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Wara}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Wara}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Wara",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Wcho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Wcho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Wcho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Wcho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Wcho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Wcho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Wcho",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Xpeo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Xpeo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Xpeo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Xpeo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Xpeo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Xpeo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Xpeo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Xsux}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Xsux}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Xsux}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Xsux}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Xsux}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Xsux}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Xsux",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Yezidi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{Script=Yezidi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{Script=Yezidi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{Script=Yezidi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{Script=Yezidi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{Script=Yezidi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Yezidi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Yezi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Yezi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Yezi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Yezi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Yezi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Yezi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Yezi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Yiii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Yiii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Yiii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Yiii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Yiii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Yiii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Yiii",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Yi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{Script=Yi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{Script=Yi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{Script=Yi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{Script=Yi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{Script=Yi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Yi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Zanabazar_Square}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script=Zanabazar_Square}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script=Zanabazar_Square}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script=Zanabazar_Square}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script=Zanabazar_Square}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script=Zanabazar_Square}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Zanabazar_Square",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Zanb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Zanb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Zanb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Zanb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Zanb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Zanb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Zanb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Zinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Zinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Zinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Zinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Zinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Zinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Zinh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script=Zyyy}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Script=Zyyy}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Script=Zyyy}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Script=Zyyy}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Script=Zyyy}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Script=Zyyy}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script",
+                    "value": "Zyyy",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Adlam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Adlam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Adlam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Adlam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Adlam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Adlam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Adlam",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Adlm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Adlm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Adlm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Adlm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Adlm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Adlm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Adlm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Aghb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Aghb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Aghb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Aghb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Aghb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Aghb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Aghb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Ahom}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Ahom}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Ahom}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Ahom}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Ahom}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Ahom}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ahom",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Anatolian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 49,
+        "raw": "/^\\p{Script_Extensions=Anatolian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 47,
+          "raw": "^\\p{Script_Extensions=Anatolian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 47,
+              "raw": "^\\p{Script_Extensions=Anatolian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 46,
+                  "raw": "\\p{Script_Extensions=Anatolian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 45,
+                    "raw": "\\p{Script_Extensions=Anatolian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Anatolian_Hieroglyphs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 46,
+                  "end": 47,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 48,
+          "end": 49,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Arabic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Arabic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Arabic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Arabic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Arabic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Arabic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Arabic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Arab}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Arab}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Arab}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Arab}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Arab}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Arab}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Arab",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Armenian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Armenian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Armenian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Armenian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Armenian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Armenian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Armenian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Armi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Armi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Armi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Armi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Armi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Armi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Armi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Armn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Armn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Armn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Armn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Armn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Armn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Armn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Avestan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Avestan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Avestan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Avestan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Avestan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Avestan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Avestan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Avst}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Avst}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Avst}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Avst}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Avst}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Avst}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Avst",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Balinese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Balinese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Balinese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Balinese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Balinese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Balinese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Balinese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Bali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Bali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Bali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Bali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Bali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Bali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bali",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Bamum}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Bamum}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Bamum}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Bamum}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Bamum}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Bamum}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bamum",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Bamu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Bamu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Bamu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Bamu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Bamu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Bamu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bamu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Bassa_Vah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{Script_Extensions=Bassa_Vah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{Script_Extensions=Bassa_Vah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{Script_Extensions=Bassa_Vah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{Script_Extensions=Bassa_Vah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{Script_Extensions=Bassa_Vah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bassa_Vah",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Bass}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Bass}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Bass}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Bass}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Bass}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Bass}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bass",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Batak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Batak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Batak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Batak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Batak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Batak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Batak",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Batk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Batk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Batk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Batk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Batk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Batk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Batk",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Bengali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Bengali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Bengali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Bengali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Bengali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Bengali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bengali",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Beng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Beng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Beng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Beng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Beng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Beng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Beng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Bhaiksuki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{Script_Extensions=Bhaiksuki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{Script_Extensions=Bhaiksuki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{Script_Extensions=Bhaiksuki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{Script_Extensions=Bhaiksuki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{Script_Extensions=Bhaiksuki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bhaiksuki",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Bhks}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Bhks}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Bhks}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Bhks}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Bhks}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Bhks}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bhks",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Bopomofo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Bopomofo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Bopomofo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Bopomofo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Bopomofo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Bopomofo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bopomofo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Bopo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Bopo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Bopo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Bopo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Bopo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Bopo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bopo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Brahmi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Brahmi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Brahmi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Brahmi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Brahmi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Brahmi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Brahmi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Brah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Brah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Brah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Brah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Brah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Brah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Brah",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Braille}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Braille}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Braille}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Braille}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Braille}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Braille}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Braille",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Brai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Brai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Brai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Brai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Brai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Brai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Brai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Buginese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Buginese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Buginese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Buginese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Buginese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Buginese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Buginese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Bugi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Bugi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Bugi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Bugi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Bugi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Bugi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Bugi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Buhd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Buhd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Buhd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Buhd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Buhd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Buhd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Buhd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Buhid}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Buhid}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Buhid}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Buhid}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Buhid}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Buhid}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Buhid",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Cakm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Cakm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Cakm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Cakm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Cakm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Cakm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cakm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Canadian_Aboriginal}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 47,
+        "raw": "/^\\p{Script_Extensions=Canadian_Aboriginal}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 45,
+          "raw": "^\\p{Script_Extensions=Canadian_Aboriginal}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 45,
+              "raw": "^\\p{Script_Extensions=Canadian_Aboriginal}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 44,
+                  "raw": "\\p{Script_Extensions=Canadian_Aboriginal}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 43,
+                    "raw": "\\p{Script_Extensions=Canadian_Aboriginal}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Canadian_Aboriginal",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 44,
+                  "end": 45,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 46,
+          "end": 47,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Cans}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Cans}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Cans}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Cans}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Cans}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Cans}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cans",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Carian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Carian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Carian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Carian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Carian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Carian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Carian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Cari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Cari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Cari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Cari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Cari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Cari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Caucasian_Albanian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 46,
+        "raw": "/^\\p{Script_Extensions=Caucasian_Albanian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 44,
+          "raw": "^\\p{Script_Extensions=Caucasian_Albanian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 44,
+              "raw": "^\\p{Script_Extensions=Caucasian_Albanian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 43,
+                  "raw": "\\p{Script_Extensions=Caucasian_Albanian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 42,
+                    "raw": "\\p{Script_Extensions=Caucasian_Albanian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Caucasian_Albanian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 43,
+                  "end": 44,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 45,
+          "end": 46,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Chakma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Chakma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Chakma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Chakma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Chakma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Chakma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Chakma",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Cham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Cham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Cham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Cham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Cham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Cham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Cherokee}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Cherokee}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Cherokee}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Cherokee}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Cherokee}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Cherokee}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cherokee",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Cher}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Cher}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Cher}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Cher}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Cher}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Cher}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cher",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Chorasmian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Script_Extensions=Chorasmian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Script_Extensions=Chorasmian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Script_Extensions=Chorasmian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Script_Extensions=Chorasmian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Script_Extensions=Chorasmian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Chorasmian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Chrs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Chrs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Chrs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Chrs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Chrs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Chrs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Chrs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Common}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Common}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Common}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Common}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Common}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Common}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Common",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Coptic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Coptic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Coptic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Coptic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Coptic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Coptic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Coptic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Copt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Copt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Copt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Copt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Copt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Copt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Copt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Cpmn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Cpmn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Cpmn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Cpmn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Cpmn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Cpmn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cpmn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Cprt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Cprt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Cprt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Cprt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Cprt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Cprt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cprt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Cuneiform}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{Script_Extensions=Cuneiform}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{Script_Extensions=Cuneiform}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{Script_Extensions=Cuneiform}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{Script_Extensions=Cuneiform}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{Script_Extensions=Cuneiform}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cuneiform",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Cypriot}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Cypriot}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Cypriot}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Cypriot}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Cypriot}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Cypriot}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cypriot",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Cypro_Minoan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^\\p{Script_Extensions=Cypro_Minoan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^\\p{Script_Extensions=Cypro_Minoan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^\\p{Script_Extensions=Cypro_Minoan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "\\p{Script_Extensions=Cypro_Minoan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "\\p{Script_Extensions=Cypro_Minoan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cypro_Minoan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Cyrillic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Cyrillic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Cyrillic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Cyrillic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Cyrillic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Cyrillic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cyrillic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Cyrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Cyrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Cyrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Cyrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Cyrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Cyrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Cyrl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Deseret}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Deseret}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Deseret}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Deseret}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Deseret}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Deseret}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Deseret",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Devanagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Script_Extensions=Devanagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Script_Extensions=Devanagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Script_Extensions=Devanagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Script_Extensions=Devanagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Script_Extensions=Devanagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Devanagari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Deva}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Deva}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Deva}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Deva}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Deva}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Deva}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Deva",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Diak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Diak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Diak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Diak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Diak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Diak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Diak",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Dives_Akuru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{Script_Extensions=Dives_Akuru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{Script_Extensions=Dives_Akuru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{Script_Extensions=Dives_Akuru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{Script_Extensions=Dives_Akuru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{Script_Extensions=Dives_Akuru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Dives_Akuru",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Dogra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Dogra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Dogra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Dogra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Dogra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Dogra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Dogra",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Dogr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Dogr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Dogr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Dogr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Dogr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Dogr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Dogr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Dsrt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Dsrt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Dsrt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Dsrt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Dsrt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Dsrt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Dsrt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Duployan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Duployan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Duployan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Duployan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Duployan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Duployan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Duployan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Dupl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Dupl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Dupl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Dupl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Dupl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Dupl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Dupl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Egyptian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 48,
+        "raw": "/^\\p{Script_Extensions=Egyptian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 46,
+          "raw": "^\\p{Script_Extensions=Egyptian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 46,
+              "raw": "^\\p{Script_Extensions=Egyptian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 45,
+                  "raw": "\\p{Script_Extensions=Egyptian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 44,
+                    "raw": "\\p{Script_Extensions=Egyptian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Egyptian_Hieroglyphs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 45,
+                  "end": 46,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 47,
+          "end": 48,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Egyp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Egyp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Egyp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Egyp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Egyp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Egyp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Egyp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Elbasan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Elbasan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Elbasan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Elbasan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Elbasan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Elbasan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Elbasan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Elba}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Elba}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Elba}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Elba}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Elba}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Elba}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Elba",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Elymaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Elymaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Elymaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Elymaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Elymaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Elymaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Elymaic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Elym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Elym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Elym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Elym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Elym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Elym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Elym",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Ethiopic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Ethiopic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Ethiopic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Ethiopic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Ethiopic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Ethiopic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ethiopic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Ethi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Ethi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Ethi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Ethi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Ethi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Ethi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ethi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Georgian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Georgian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Georgian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Georgian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Georgian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Georgian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Georgian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Geor}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Geor}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Geor}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Geor}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Geor}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Geor}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Geor",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Glagolitic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Script_Extensions=Glagolitic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Script_Extensions=Glagolitic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Script_Extensions=Glagolitic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Script_Extensions=Glagolitic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Script_Extensions=Glagolitic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Glagolitic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Glag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Glag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Glag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Glag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Glag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Glag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Glag",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Gong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Gong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Gong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Gong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Gong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Gong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Gonm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Gonm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Gonm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Gonm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Gonm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Gonm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gonm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Gothic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Gothic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Gothic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Gothic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Gothic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Gothic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gothic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Goth}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Goth}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Goth}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Goth}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Goth}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Goth}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Goth",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Grantha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Grantha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Grantha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Grantha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Grantha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Grantha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Grantha",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Gran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Gran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Gran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Gran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Gran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Gran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gran",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Greek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Greek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Greek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Greek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Greek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Greek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Greek",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Grek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Grek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Grek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Grek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Grek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Grek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Grek",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Gujarati}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Gujarati}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Gujarati}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Gujarati}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Gujarati}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Gujarati}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gujarati",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Gujr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Gujr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Gujr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Gujr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Gujr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Gujr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gujr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Gunjala_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\p{Script_Extensions=Gunjala_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\p{Script_Extensions=Gunjala_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\p{Script_Extensions=Gunjala_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\p{Script_Extensions=Gunjala_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\p{Script_Extensions=Gunjala_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gunjala_Gondi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Gurmukhi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Gurmukhi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Gurmukhi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Gurmukhi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Gurmukhi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Gurmukhi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Gurmukhi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Guru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Guru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Guru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Guru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Guru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Guru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Guru",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hangul}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Hangul}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Hangul}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Hangul}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Hangul}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Hangul}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hangul",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Hang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Hang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Hang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Hang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Hang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hang",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hanifi_Rohingya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\p{Script_Extensions=Hanifi_Rohingya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\p{Script_Extensions=Hanifi_Rohingya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\p{Script_Extensions=Hanifi_Rohingya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\p{Script_Extensions=Hanifi_Rohingya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\p{Script_Extensions=Hanifi_Rohingya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hanifi_Rohingya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Hani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Hani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Hani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Hani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Hani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hano}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Hano}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Hano}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Hano}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Hano}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Hano}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hano",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hanunoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Hanunoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Hanunoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Hanunoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Hanunoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Hanunoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hanunoo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Han}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\p{Script_Extensions=Han}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\p{Script_Extensions=Han}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\p{Script_Extensions=Han}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\p{Script_Extensions=Han}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\p{Script_Extensions=Han}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Han",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hatran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Hatran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Hatran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Hatran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Hatran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Hatran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hatran",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hatr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Hatr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Hatr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Hatr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Hatr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Hatr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hatr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hebrew}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Hebrew}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Hebrew}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Hebrew}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Hebrew}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Hebrew}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hebrew",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hebr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Hebr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Hebr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Hebr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Hebr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Hebr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hebr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hiragana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Hiragana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Hiragana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Hiragana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Hiragana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Hiragana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hiragana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hira}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Hira}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Hira}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Hira}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Hira}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Hira}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hira",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hluw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Hluw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Hluw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Hluw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Hluw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Hluw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hluw",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hmng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Hmng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Hmng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Hmng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Hmng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Hmng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hmng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hmnp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Hmnp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Hmnp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Hmnp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Hmnp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Hmnp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hmnp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Hung}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Hung}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Hung}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Hung}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Hung}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Hung}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Hung",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Imperial_Aramaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/^\\p{Script_Extensions=Imperial_Aramaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 42,
+          "raw": "^\\p{Script_Extensions=Imperial_Aramaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 42,
+              "raw": "^\\p{Script_Extensions=Imperial_Aramaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 41,
+                  "raw": "\\p{Script_Extensions=Imperial_Aramaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 40,
+                    "raw": "\\p{Script_Extensions=Imperial_Aramaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Imperial_Aramaic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 41,
+                  "end": 42,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 43,
+          "end": 44,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Inherited}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{Script_Extensions=Inherited}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{Script_Extensions=Inherited}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{Script_Extensions=Inherited}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{Script_Extensions=Inherited}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{Script_Extensions=Inherited}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Inherited",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Inscriptional_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 49,
+        "raw": "/^\\p{Script_Extensions=Inscriptional_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 47,
+          "raw": "^\\p{Script_Extensions=Inscriptional_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 47,
+              "raw": "^\\p{Script_Extensions=Inscriptional_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 46,
+                  "raw": "\\p{Script_Extensions=Inscriptional_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 45,
+                    "raw": "\\p{Script_Extensions=Inscriptional_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Inscriptional_Pahlavi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 46,
+                  "end": 47,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 48,
+          "end": 49,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Inscriptional_Parthian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 50,
+        "raw": "/^\\p{Script_Extensions=Inscriptional_Parthian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 48,
+          "raw": "^\\p{Script_Extensions=Inscriptional_Parthian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 48,
+              "raw": "^\\p{Script_Extensions=Inscriptional_Parthian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 47,
+                  "raw": "\\p{Script_Extensions=Inscriptional_Parthian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 46,
+                    "raw": "\\p{Script_Extensions=Inscriptional_Parthian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Inscriptional_Parthian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 47,
+                  "end": 48,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 49,
+          "end": 50,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Ital}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Ital}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Ital}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Ital}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Ital}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Ital}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ital",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Javanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Javanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Javanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Javanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Javanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Javanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Javanese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Java}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Java}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Java}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Java}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Java}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Java}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Java",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Kaithi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Kaithi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Kaithi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Kaithi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Kaithi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Kaithi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kaithi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Kali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Kali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Kali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Kali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Kali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Kali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kali",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Kana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Kana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Kana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Kana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Kana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Kana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Kannada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Kannada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Kannada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Kannada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Kannada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Kannada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kannada",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Katakana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Katakana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Katakana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Katakana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Katakana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Katakana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Katakana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Kawi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Kawi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Kawi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Kawi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Kawi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Kawi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kawi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Kayah_Li}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Kayah_Li}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Kayah_Li}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Kayah_Li}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Kayah_Li}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Kayah_Li}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kayah_Li",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Kharoshthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Script_Extensions=Kharoshthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Script_Extensions=Kharoshthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Script_Extensions=Kharoshthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Script_Extensions=Kharoshthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Script_Extensions=Kharoshthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kharoshthi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Khar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Khar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Khar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Khar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Khar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Khar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Khitan_Small_Script}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 47,
+        "raw": "/^\\p{Script_Extensions=Khitan_Small_Script}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 45,
+          "raw": "^\\p{Script_Extensions=Khitan_Small_Script}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 45,
+              "raw": "^\\p{Script_Extensions=Khitan_Small_Script}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 44,
+                  "raw": "\\p{Script_Extensions=Khitan_Small_Script}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 43,
+                    "raw": "\\p{Script_Extensions=Khitan_Small_Script}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khitan_Small_Script",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 44,
+                  "end": 45,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 46,
+          "end": 47,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Khmer}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Khmer}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Khmer}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Khmer}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Khmer}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Khmer}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khmer",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Khmr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Khmr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Khmr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Khmr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Khmr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Khmr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khmr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Khojki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Khojki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Khojki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Khojki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Khojki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Khojki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khojki",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Khoj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Khoj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Khoj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Khoj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Khoj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Khoj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khoj",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Khudawadi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{Script_Extensions=Khudawadi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{Script_Extensions=Khudawadi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{Script_Extensions=Khudawadi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{Script_Extensions=Khudawadi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{Script_Extensions=Khudawadi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Khudawadi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Kits}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Kits}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Kits}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Kits}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Kits}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Kits}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kits",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Knda}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Knda}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Knda}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Knda}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Knda}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Knda}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Knda",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Kthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Kthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Kthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Kthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Kthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Kthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Kthi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Lana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Lana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Lana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Lana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Lana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Lana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Laoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Laoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Laoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Laoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Laoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Laoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Laoo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Lao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\p{Script_Extensions=Lao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\p{Script_Extensions=Lao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\p{Script_Extensions=Lao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\p{Script_Extensions=Lao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\p{Script_Extensions=Lao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lao",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Latin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Latin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Latin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Latin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Latin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Latin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Latin",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Latn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Latn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Latn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Latn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Latn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Latn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Latn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Lepcha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Lepcha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Lepcha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Lepcha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Lepcha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Lepcha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lepcha",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Lepc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Lepc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Lepc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Lepc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Lepc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Lepc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lepc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Limbu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Limbu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Limbu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Limbu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Limbu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Limbu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Limbu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Limb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Limb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Limb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Limb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Limb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Limb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Limb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Lina}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Lina}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Lina}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Lina}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Lina}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Lina}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lina",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Linb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Linb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Linb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Linb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Linb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Linb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Linb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Linear_A}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Linear_A}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Linear_A}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Linear_A}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Linear_A}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Linear_A}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Linear_A",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Linear_B}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Linear_B}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Linear_B}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Linear_B}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Linear_B}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Linear_B}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Linear_B",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Lisu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Lisu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Lisu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Lisu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Lisu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Lisu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lisu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Lycian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Lycian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Lycian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Lycian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Lycian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Lycian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lycian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Lyci}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Lyci}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Lyci}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Lyci}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Lyci}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Lyci}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lyci",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Lydian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Lydian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Lydian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Lydian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Lydian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Lydian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lydian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Lydi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Lydi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Lydi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Lydi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Lydi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Lydi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Lydi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mahajani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Mahajani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Mahajani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Mahajani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Mahajani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Mahajani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mahajani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mahj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Mahj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Mahj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Mahj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Mahj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Mahj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mahj",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Makasar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Makasar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Makasar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Makasar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Makasar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Makasar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Makasar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Maka}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Maka}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Maka}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Maka}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Maka}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Maka}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Maka",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Malayalam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{Script_Extensions=Malayalam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{Script_Extensions=Malayalam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{Script_Extensions=Malayalam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{Script_Extensions=Malayalam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{Script_Extensions=Malayalam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Malayalam",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mandaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Mandaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Mandaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Mandaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Mandaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Mandaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mandaic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Mand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Mand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Mand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Mand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Mand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mand",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Manichaean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Script_Extensions=Manichaean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Script_Extensions=Manichaean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Script_Extensions=Manichaean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Script_Extensions=Manichaean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Script_Extensions=Manichaean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Manichaean",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Mani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Mani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Mani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Mani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Mani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Marchen}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Marchen}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Marchen}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Marchen}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Marchen}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Marchen}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Marchen",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Marc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Marc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Marc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Marc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Marc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Marc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Marc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Masaram_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\p{Script_Extensions=Masaram_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\p{Script_Extensions=Masaram_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\p{Script_Extensions=Masaram_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\p{Script_Extensions=Masaram_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\p{Script_Extensions=Masaram_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Masaram_Gondi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Medefaidrin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{Script_Extensions=Medefaidrin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{Script_Extensions=Medefaidrin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{Script_Extensions=Medefaidrin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{Script_Extensions=Medefaidrin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{Script_Extensions=Medefaidrin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Medefaidrin",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Medf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Medf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Medf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Medf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Medf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Medf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Medf",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Meetei_Mayek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^\\p{Script_Extensions=Meetei_Mayek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^\\p{Script_Extensions=Meetei_Mayek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^\\p{Script_Extensions=Meetei_Mayek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "\\p{Script_Extensions=Meetei_Mayek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "\\p{Script_Extensions=Meetei_Mayek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Meetei_Mayek",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mende_Kikakui}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\p{Script_Extensions=Mende_Kikakui}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\p{Script_Extensions=Mende_Kikakui}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\p{Script_Extensions=Mende_Kikakui}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\p{Script_Extensions=Mende_Kikakui}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\p{Script_Extensions=Mende_Kikakui}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mende_Kikakui",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mend}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Mend}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Mend}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Mend}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Mend}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Mend}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mend",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Merc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Merc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Merc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Merc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Merc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Merc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Merc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Meroitic_Cursive}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/^\\p{Script_Extensions=Meroitic_Cursive}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 42,
+          "raw": "^\\p{Script_Extensions=Meroitic_Cursive}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 42,
+              "raw": "^\\p{Script_Extensions=Meroitic_Cursive}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 41,
+                  "raw": "\\p{Script_Extensions=Meroitic_Cursive}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 40,
+                    "raw": "\\p{Script_Extensions=Meroitic_Cursive}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Meroitic_Cursive",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 41,
+                  "end": 42,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 43,
+          "end": 44,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Meroitic_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 48,
+        "raw": "/^\\p{Script_Extensions=Meroitic_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 46,
+          "raw": "^\\p{Script_Extensions=Meroitic_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 46,
+              "raw": "^\\p{Script_Extensions=Meroitic_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 45,
+                  "raw": "\\p{Script_Extensions=Meroitic_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 44,
+                    "raw": "\\p{Script_Extensions=Meroitic_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Meroitic_Hieroglyphs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 45,
+                  "end": 46,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 47,
+          "end": 48,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mero}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Mero}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Mero}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Mero}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Mero}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Mero}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mero",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Miao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Miao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Miao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Miao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Miao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Miao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Miao",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mlym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Mlym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Mlym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Mlym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Mlym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Mlym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mlym",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Modi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Modi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Modi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Modi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Modi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Modi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Modi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mongolian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{Script_Extensions=Mongolian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{Script_Extensions=Mongolian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{Script_Extensions=Mongolian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{Script_Extensions=Mongolian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{Script_Extensions=Mongolian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mongolian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Mong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Mong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Mong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Mong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Mong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mroo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Mroo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Mroo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Mroo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Mroo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Mroo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mroo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mro}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\p{Script_Extensions=Mro}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\p{Script_Extensions=Mro}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\p{Script_Extensions=Mro}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\p{Script_Extensions=Mro}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\p{Script_Extensions=Mro}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mro",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mtei}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Mtei}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Mtei}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Mtei}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Mtei}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Mtei}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mtei",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Multani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Multani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Multani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Multani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Multani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Multani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Multani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mult}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Mult}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Mult}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Mult}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Mult}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Mult}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mult",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Myanmar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Myanmar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Myanmar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Myanmar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Myanmar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Myanmar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Myanmar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Mymr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Mymr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Mymr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Mymr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Mymr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Mymr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Mymr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Nabataean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{Script_Extensions=Nabataean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{Script_Extensions=Nabataean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{Script_Extensions=Nabataean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{Script_Extensions=Nabataean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{Script_Extensions=Nabataean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nabataean",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Nag_Mundari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{Script_Extensions=Nag_Mundari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{Script_Extensions=Nag_Mundari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{Script_Extensions=Nag_Mundari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{Script_Extensions=Nag_Mundari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{Script_Extensions=Nag_Mundari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nag_Mundari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Nagm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Nagm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Nagm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Nagm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Nagm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Nagm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nagm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Nandinagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{Script_Extensions=Nandinagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{Script_Extensions=Nandinagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{Script_Extensions=Nandinagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{Script_Extensions=Nandinagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{Script_Extensions=Nandinagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nandinagari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Nand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Nand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Nand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Nand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Nand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Nand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nand",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Narb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Narb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Narb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Narb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Narb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Narb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Narb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Nbat}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Nbat}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Nbat}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Nbat}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Nbat}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Nbat}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nbat",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=New_Tai_Lue}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{Script_Extensions=New_Tai_Lue}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{Script_Extensions=New_Tai_Lue}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{Script_Extensions=New_Tai_Lue}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{Script_Extensions=New_Tai_Lue}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{Script_Extensions=New_Tai_Lue}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "New_Tai_Lue",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Newa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Newa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Newa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Newa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Newa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Newa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Newa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Nkoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Nkoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Nkoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Nkoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Nkoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Nkoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nkoo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Nko}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\p{Script_Extensions=Nko}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\p{Script_Extensions=Nko}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\p{Script_Extensions=Nko}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\p{Script_Extensions=Nko}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\p{Script_Extensions=Nko}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nko",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Nshu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Nshu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Nshu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Nshu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Nshu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Nshu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nshu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Nushu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Nushu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Nushu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Nushu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Nushu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Nushu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nushu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Nyiakeng_Puachue_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 50,
+        "raw": "/^\\p{Script_Extensions=Nyiakeng_Puachue_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 48,
+          "raw": "^\\p{Script_Extensions=Nyiakeng_Puachue_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 48,
+              "raw": "^\\p{Script_Extensions=Nyiakeng_Puachue_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 47,
+                  "raw": "\\p{Script_Extensions=Nyiakeng_Puachue_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 46,
+                    "raw": "\\p{Script_Extensions=Nyiakeng_Puachue_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Nyiakeng_Puachue_Hmong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 47,
+                  "end": 48,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 49,
+          "end": 50,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Ogam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Ogam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Ogam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Ogam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Ogam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Ogam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ogam",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Ogham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Ogham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Ogham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Ogham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Ogham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Ogham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ogham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Ol_Chiki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Ol_Chiki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Ol_Chiki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Ol_Chiki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Ol_Chiki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Ol_Chiki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ol_Chiki",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Olck}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Olck}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Olck}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Olck}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Olck}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Olck}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Olck",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Old_Hungarian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 41,
+        "raw": "/^\\p{Script_Extensions=Old_Hungarian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 39,
+          "raw": "^\\p{Script_Extensions=Old_Hungarian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 39,
+              "raw": "^\\p{Script_Extensions=Old_Hungarian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 38,
+                  "raw": "\\p{Script_Extensions=Old_Hungarian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 37,
+                    "raw": "\\p{Script_Extensions=Old_Hungarian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Hungarian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 38,
+                  "end": 39,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 40,
+          "end": 41,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Old_Italic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Script_Extensions=Old_Italic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Script_Extensions=Old_Italic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Script_Extensions=Old_Italic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Script_Extensions=Old_Italic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Script_Extensions=Old_Italic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Italic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Old_North_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 45,
+        "raw": "/^\\p{Script_Extensions=Old_North_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 43,
+          "raw": "^\\p{Script_Extensions=Old_North_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 43,
+              "raw": "^\\p{Script_Extensions=Old_North_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 42,
+                  "raw": "\\p{Script_Extensions=Old_North_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 41,
+                    "raw": "\\p{Script_Extensions=Old_North_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_North_Arabian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 42,
+                  "end": 43,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 44,
+          "end": 45,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Old_Permic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Script_Extensions=Old_Permic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Script_Extensions=Old_Permic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Script_Extensions=Old_Permic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Script_Extensions=Old_Permic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Script_Extensions=Old_Permic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Permic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Old_Persian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{Script_Extensions=Old_Persian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{Script_Extensions=Old_Persian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{Script_Extensions=Old_Persian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{Script_Extensions=Old_Persian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{Script_Extensions=Old_Persian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Persian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Old_Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{Script_Extensions=Old_Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{Script_Extensions=Old_Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{Script_Extensions=Old_Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{Script_Extensions=Old_Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{Script_Extensions=Old_Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Sogdian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Old_South_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 45,
+        "raw": "/^\\p{Script_Extensions=Old_South_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 43,
+          "raw": "^\\p{Script_Extensions=Old_South_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 43,
+              "raw": "^\\p{Script_Extensions=Old_South_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 42,
+                  "raw": "\\p{Script_Extensions=Old_South_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 41,
+                    "raw": "\\p{Script_Extensions=Old_South_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_South_Arabian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 42,
+                  "end": 43,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 44,
+          "end": 45,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Old_Turkic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Script_Extensions=Old_Turkic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Script_Extensions=Old_Turkic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Script_Extensions=Old_Turkic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Script_Extensions=Old_Turkic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Script_Extensions=Old_Turkic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Turkic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Old_Uyghur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Script_Extensions=Old_Uyghur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Script_Extensions=Old_Uyghur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Script_Extensions=Old_Uyghur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Script_Extensions=Old_Uyghur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Script_Extensions=Old_Uyghur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Old_Uyghur",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Oriya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Oriya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Oriya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Oriya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Oriya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Oriya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Oriya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Orkh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Orkh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Orkh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Orkh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Orkh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Orkh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Orkh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Orya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Orya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Orya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Orya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Orya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Orya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Orya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Osage}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Osage}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Osage}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Osage}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Osage}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Osage}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Osage",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Osge}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Osge}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Osge}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Osge}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Osge}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Osge}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Osge",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Osmanya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Osmanya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Osmanya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Osmanya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Osmanya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Osmanya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Osmanya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Osma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Osma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Osma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Osma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Osma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Osma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Osma",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Ougr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Ougr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Ougr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Ougr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Ougr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Ougr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ougr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Pahawh_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^\\p{Script_Extensions=Pahawh_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^\\p{Script_Extensions=Pahawh_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^\\p{Script_Extensions=Pahawh_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "\\p{Script_Extensions=Pahawh_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "\\p{Script_Extensions=Pahawh_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Pahawh_Hmong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Palmyrene}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{Script_Extensions=Palmyrene}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{Script_Extensions=Palmyrene}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{Script_Extensions=Palmyrene}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{Script_Extensions=Palmyrene}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{Script_Extensions=Palmyrene}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Palmyrene",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Palm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Palm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Palm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Palm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Palm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Palm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Palm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Pau_Cin_Hau}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{Script_Extensions=Pau_Cin_Hau}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{Script_Extensions=Pau_Cin_Hau}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{Script_Extensions=Pau_Cin_Hau}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{Script_Extensions=Pau_Cin_Hau}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{Script_Extensions=Pau_Cin_Hau}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Pau_Cin_Hau",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Pauc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Pauc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Pauc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Pauc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Pauc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Pauc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Pauc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Perm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Perm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Perm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Perm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Perm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Perm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Perm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Phags_Pa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Phags_Pa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Phags_Pa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Phags_Pa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Phags_Pa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Phags_Pa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Phags_Pa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Phag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Phag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Phag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Phag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Phag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Phag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Phag",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Phli}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Phli}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Phli}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Phli}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Phli}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Phli}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Phli",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Phlp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Phlp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Phlp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Phlp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Phlp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Phlp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Phlp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Phnx}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Phnx}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Phnx}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Phnx}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Phnx}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Phnx}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Phnx",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Phoenician}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Script_Extensions=Phoenician}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Script_Extensions=Phoenician}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Script_Extensions=Phoenician}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Script_Extensions=Phoenician}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Script_Extensions=Phoenician}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Phoenician",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Plrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Plrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Plrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Plrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Plrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Plrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Plrd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Prti}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Prti}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Prti}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Prti}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Prti}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Prti}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Prti",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Psalter_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 43,
+        "raw": "/^\\p{Script_Extensions=Psalter_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 41,
+          "raw": "^\\p{Script_Extensions=Psalter_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 41,
+              "raw": "^\\p{Script_Extensions=Psalter_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 40,
+                  "raw": "\\p{Script_Extensions=Psalter_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 39,
+                    "raw": "\\p{Script_Extensions=Psalter_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Psalter_Pahlavi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 40,
+                  "end": 41,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 42,
+          "end": 43,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Qaac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Qaac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Qaac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Qaac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Qaac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Qaac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Qaac",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Qaai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Qaai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Qaai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Qaai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Qaai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Qaai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Qaai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Rejang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Rejang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Rejang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Rejang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Rejang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Rejang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Rejang",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Rjng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Rjng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Rjng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Rjng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Rjng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Rjng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Rjng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Rohg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Rohg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Rohg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Rohg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Rohg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Rohg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Rohg",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Runic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Runic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Runic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Runic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Runic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Runic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Runic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Runr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Runr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Runr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Runr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Runr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Runr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Runr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Samaritan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{Script_Extensions=Samaritan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{Script_Extensions=Samaritan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{Script_Extensions=Samaritan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{Script_Extensions=Samaritan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{Script_Extensions=Samaritan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Samaritan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Samr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Samr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Samr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Samr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Samr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Samr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Samr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sarb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Sarb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Sarb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Sarb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Sarb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Sarb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sarb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Saurashtra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^\\p{Script_Extensions=Saurashtra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^\\p{Script_Extensions=Saurashtra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^\\p{Script_Extensions=Saurashtra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "\\p{Script_Extensions=Saurashtra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "\\p{Script_Extensions=Saurashtra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Saurashtra",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Saur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Saur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Saur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Saur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Saur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Saur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Saur",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sgnw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Sgnw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Sgnw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Sgnw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Sgnw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Sgnw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sgnw",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sharada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Sharada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Sharada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Sharada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Sharada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Sharada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sharada",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Shavian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Shavian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Shavian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Shavian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Shavian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Shavian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Shavian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Shaw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Shaw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Shaw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Shaw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Shaw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Shaw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Shaw",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Shrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Shrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Shrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Shrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Shrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Shrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Shrd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Siddham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Siddham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Siddham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Siddham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Siddham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Siddham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Siddham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sidd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Sidd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Sidd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Sidd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Sidd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Sidd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sidd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=SignWriting}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{Script_Extensions=SignWriting}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{Script_Extensions=SignWriting}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{Script_Extensions=SignWriting}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{Script_Extensions=SignWriting}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{Script_Extensions=SignWriting}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "SignWriting",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sind}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Sind}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Sind}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Sind}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Sind}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Sind}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sind",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sinhala}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Sinhala}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Sinhala}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Sinhala}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Sinhala}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Sinhala}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sinhala",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Sinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Sinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Sinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Sinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Sinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sinh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sogdian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sogd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Sogd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Sogd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Sogd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Sogd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Sogd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sogd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sogo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Sogo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Sogo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Sogo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Sogo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Sogo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sogo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sora_Sompeng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^\\p{Script_Extensions=Sora_Sompeng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^\\p{Script_Extensions=Sora_Sompeng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^\\p{Script_Extensions=Sora_Sompeng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "\\p{Script_Extensions=Sora_Sompeng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "\\p{Script_Extensions=Sora_Sompeng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sora_Sompeng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sora}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Sora}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Sora}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Sora}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Sora}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Sora}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sora",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Soyombo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Soyombo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Soyombo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Soyombo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Soyombo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Soyombo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Soyombo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Soyo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Soyo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Soyo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Soyo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Soyo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Soyo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Soyo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sundanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 37,
+        "raw": "/^\\p{Script_Extensions=Sundanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 35,
+          "raw": "^\\p{Script_Extensions=Sundanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 35,
+              "raw": "^\\p{Script_Extensions=Sundanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 34,
+                  "raw": "\\p{Script_Extensions=Sundanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 33,
+                    "raw": "\\p{Script_Extensions=Sundanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sundanese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 34,
+                  "end": 35,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 36,
+          "end": 37,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sund}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Sund}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Sund}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Sund}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Sund}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Sund}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sund",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Syloti_Nagri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 40,
+        "raw": "/^\\p{Script_Extensions=Syloti_Nagri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 38,
+          "raw": "^\\p{Script_Extensions=Syloti_Nagri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 38,
+              "raw": "^\\p{Script_Extensions=Syloti_Nagri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 37,
+                  "raw": "\\p{Script_Extensions=Syloti_Nagri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 36,
+                    "raw": "\\p{Script_Extensions=Syloti_Nagri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Syloti_Nagri",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 37,
+                  "end": 38,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 39,
+          "end": 40,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Sylo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Sylo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Sylo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Sylo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Sylo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Sylo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Sylo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Syrc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Syrc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Syrc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Syrc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Syrc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Syrc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Syrc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Syriac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Syriac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Syriac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Syriac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Syriac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Syriac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Syriac",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tagalog}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Tagalog}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Tagalog}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Tagalog}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Tagalog}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Tagalog}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tagalog",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tagbanwa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Tagbanwa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Tagbanwa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Tagbanwa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Tagbanwa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Tagbanwa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tagbanwa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tagb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Tagb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Tagb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Tagb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Tagb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Tagb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tagb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tai_Le}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Tai_Le}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Tai_Le}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Tai_Le}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Tai_Le}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Tai_Le}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tai_Le",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tai_Tham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Tai_Tham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Tai_Tham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Tai_Tham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Tai_Tham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Tai_Tham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tai_Tham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tai_Viet}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Tai_Viet}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Tai_Viet}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Tai_Viet}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Tai_Viet}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Tai_Viet}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tai_Viet",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Takri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Takri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Takri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Takri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Takri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Takri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Takri",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Takr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Takr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Takr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Takr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Takr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Takr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Takr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tale}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Tale}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Tale}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Tale}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Tale}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Tale}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tale",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Talu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Talu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Talu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Talu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Talu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Talu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Talu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tamil}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{Script_Extensions=Tamil}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{Script_Extensions=Tamil}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{Script_Extensions=Tamil}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{Script_Extensions=Tamil}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{Script_Extensions=Tamil}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tamil",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Taml}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Taml}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Taml}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Taml}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Taml}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Taml}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Taml",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tangsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Tangsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Tangsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Tangsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Tangsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Tangsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tangsa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tangut}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Tangut}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Tangut}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Tangut}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Tangut}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Tangut}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tangut",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Tang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Tang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Tang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Tang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Tang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tang",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tavt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Tavt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Tavt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Tavt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Tavt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Tavt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tavt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Telugu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Telugu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Telugu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Telugu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Telugu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Telugu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Telugu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Telu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Telu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Telu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Telu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Telu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Telu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Telu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tfng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Tfng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Tfng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Tfng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Tfng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Tfng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tfng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tglg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Tglg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Tglg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Tglg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Tglg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Tglg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tglg",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Thaana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Thaana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Thaana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Thaana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Thaana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Thaana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Thaana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Thaa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Thaa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Thaa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Thaa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Thaa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Thaa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Thaa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Thai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Thai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Thai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Thai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Thai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Thai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Thai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tibetan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Tibetan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Tibetan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Tibetan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Tibetan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Tibetan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tibetan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tibt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Tibt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Tibt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Tibt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Tibt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Tibt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tibt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tifinagh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Tifinagh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Tifinagh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Tifinagh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Tifinagh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Tifinagh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tifinagh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tirhuta}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{Script_Extensions=Tirhuta}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{Script_Extensions=Tirhuta}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{Script_Extensions=Tirhuta}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{Script_Extensions=Tirhuta}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{Script_Extensions=Tirhuta}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tirhuta",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tirh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Tirh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Tirh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Tirh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Tirh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Tirh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tirh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Tnsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Tnsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Tnsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Tnsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Tnsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Tnsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Tnsa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Toto}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Toto}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Toto}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Toto}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Toto}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Toto}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Toto",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Ugaritic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Ugaritic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Ugaritic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Ugaritic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Ugaritic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Ugaritic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ugaritic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Ugar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Ugar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Ugar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Ugar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Ugar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Ugar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Ugar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Vaii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Vaii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Vaii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Vaii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Vaii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Vaii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Vaii",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Vai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\p{Script_Extensions=Vai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\p{Script_Extensions=Vai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\p{Script_Extensions=Vai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\p{Script_Extensions=Vai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\p{Script_Extensions=Vai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Vai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Vithkuqi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{Script_Extensions=Vithkuqi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{Script_Extensions=Vithkuqi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{Script_Extensions=Vithkuqi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{Script_Extensions=Vithkuqi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{Script_Extensions=Vithkuqi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Vithkuqi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Vith}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Vith}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Vith}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Vith}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Vith}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Vith}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Vith",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Wancho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Wancho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Wancho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Wancho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Wancho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Wancho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Wancho",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Warang_Citi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 39,
+        "raw": "/^\\p{Script_Extensions=Warang_Citi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 37,
+          "raw": "^\\p{Script_Extensions=Warang_Citi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 37,
+              "raw": "^\\p{Script_Extensions=Warang_Citi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 36,
+                  "raw": "\\p{Script_Extensions=Warang_Citi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 35,
+                    "raw": "\\p{Script_Extensions=Warang_Citi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Warang_Citi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 36,
+                  "end": 37,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 38,
+          "end": 39,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Wara}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Wara}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Wara}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Wara}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Wara}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Wara}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Wara",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Wcho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Wcho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Wcho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Wcho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Wcho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Wcho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Wcho",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Xpeo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Xpeo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Xpeo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Xpeo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Xpeo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Xpeo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Xpeo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Xsux}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Xsux}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Xsux}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Xsux}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Xsux}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Xsux}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Xsux",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Yezidi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{Script_Extensions=Yezidi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{Script_Extensions=Yezidi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{Script_Extensions=Yezidi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{Script_Extensions=Yezidi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{Script_Extensions=Yezidi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Yezidi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Yezi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Yezi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Yezi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Yezi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Yezi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Yezi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Yezi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Yiii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Yiii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Yiii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Yiii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Yiii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Yiii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Yiii",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Yi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{Script_Extensions=Yi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{Script_Extensions=Yi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{Script_Extensions=Yi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{Script_Extensions=Yi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{Script_Extensions=Yi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Yi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Zanabazar_Square}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 44,
+        "raw": "/^\\p{Script_Extensions=Zanabazar_Square}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 42,
+          "raw": "^\\p{Script_Extensions=Zanabazar_Square}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 42,
+              "raw": "^\\p{Script_Extensions=Zanabazar_Square}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 41,
+                  "raw": "\\p{Script_Extensions=Zanabazar_Square}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 40,
+                    "raw": "\\p{Script_Extensions=Zanabazar_Square}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Zanabazar_Square",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 41,
+                  "end": 42,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 43,
+          "end": 44,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Zanb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Zanb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Zanb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Zanb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Zanb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Zanb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Zanb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Zinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Zinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Zinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Zinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Zinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Zinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Zinh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Script_Extensions=Zyyy}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{Script_Extensions=Zyyy}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{Script_Extensions=Zyyy}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{Script_Extensions=Zyyy}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{Script_Extensions=Zyyy}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{Script_Extensions=Zyyy}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Script_Extensions",
+                    "value": "Zyyy",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Sc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Sc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Sc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Sc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Sc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Sc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Sc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Sentence_Terminal}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Sentence_Terminal}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Sentence_Terminal}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Sentence_Terminal}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Sentence_Terminal}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Sentence_Terminal}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Sentence_Terminal",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Separator",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Sk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Sk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Sk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Sk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Sk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Sk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Sk",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Sm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Sm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Sm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Sm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Sm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Sm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Sm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Soft_Dotted}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{Soft_Dotted}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{Soft_Dotted}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{Soft_Dotted}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{Soft_Dotted}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{Soft_Dotted}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Soft_Dotted",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{So}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{So}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{So}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{So}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{So}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{So}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "So",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Space_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{Space_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{Space_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{Space_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{Space_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{Space_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Space_Separator",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Spacing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{Spacing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{Spacing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{Spacing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{Spacing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{Spacing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Spacing_Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Surrogate}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{Surrogate}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{Surrogate}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{Surrogate}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{Surrogate}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{Surrogate}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Surrogate",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{S}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\p{S}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\p{S}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\p{S}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\p{S}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\p{S}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "S",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Terminal_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{Terminal_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{Terminal_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{Terminal_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{Terminal_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{Terminal_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Terminal_Punctuation",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Term}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{Term}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{Term}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{Term}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{Term}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{Term}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Term",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Titlecase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Titlecase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Titlecase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Titlecase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Titlecase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Titlecase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Titlecase_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{UIdeo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{UIdeo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{UIdeo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{UIdeo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{UIdeo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{UIdeo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "UIdeo",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Unassigned}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{Unassigned}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{Unassigned}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{Unassigned}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{Unassigned}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{Unassigned}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Unassigned",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Unified_Ideograph}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{Unified_Ideograph}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{Unified_Ideograph}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{Unified_Ideograph}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{Unified_Ideograph}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{Unified_Ideograph}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Unified_Ideograph",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Uppercase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{Uppercase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{Uppercase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{Uppercase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{Uppercase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{Uppercase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Uppercase_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Uppercase}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{Uppercase}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{Uppercase}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{Uppercase}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{Uppercase}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{Uppercase}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Uppercase",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Upper}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{Upper}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{Upper}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{Upper}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{Upper}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{Upper}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Upper",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{VS}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{VS}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{VS}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{VS}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{VS}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{VS}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "VS",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Variation_Selector}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{Variation_Selector}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{Variation_Selector}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{Variation_Selector}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{Variation_Selector}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{Variation_Selector}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "Variation_Selector",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{White_Space}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{White_Space}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{White_Space}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{White_Space}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{White_Space}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{White_Space}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "White_Space",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{XIDC}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{XIDC}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{XIDC}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{XIDC}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{XIDC}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{XIDC}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "XIDC",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{XIDS}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{XIDS}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{XIDS}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{XIDS}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{XIDS}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{XIDS}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "XIDS",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{XID_Continue}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{XID_Continue}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{XID_Continue}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{XID_Continue}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{XID_Continue}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{XID_Continue}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "XID_Continue",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{XID_Start}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{XID_Start}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{XID_Start}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{XID_Start}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{XID_Start}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{XID_Start}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "XID_Start",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Zl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Zl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Zl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Zl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Zl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Zl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Zl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Zp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Zp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Zp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Zp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Zp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Zp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Zp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Zs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^\\p{Zs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^\\p{Zs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^\\p{Zs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "\\p{Zs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "\\p{Zs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Zs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{Z}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^\\p{Z}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^\\p{Z}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^\\p{Z}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "\\p{Z}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "\\p{Z}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "Z",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{cntrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{cntrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{cntrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{cntrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{cntrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{cntrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "cntrl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{digit}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{digit}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{digit}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{digit}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{digit}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{digit}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "digit",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Cased_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{gc=Cased_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{gc=Cased_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{gc=Cased_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{gc=Cased_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{gc=Cased_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Cased_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Cc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Cc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Cc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Cc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Cc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Cc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Cc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Cf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Cf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Cf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Cf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Cf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Cf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Cf",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Close_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{gc=Close_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{gc=Close_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{gc=Close_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{gc=Close_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{gc=Close_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Close_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Cn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Cn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Cn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Cn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Cn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Cn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Cn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Combining_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{gc=Combining_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{gc=Combining_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{gc=Combining_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{gc=Combining_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{gc=Combining_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Combining_Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Connector_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{gc=Connector_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{gc=Connector_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{gc=Connector_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{gc=Connector_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{gc=Connector_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Connector_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Control}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{gc=Control}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{gc=Control}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{gc=Control}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{gc=Control}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{gc=Control}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Control",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Co}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Co}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Co}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Co}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Co}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Co}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Co",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Cs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Cs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Cs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Cs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Cs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Cs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Cs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Currency_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{gc=Currency_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{gc=Currency_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{gc=Currency_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{gc=Currency_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{gc=Currency_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Currency_Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=C}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{gc=C}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{gc=C}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{gc=C}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{gc=C}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{gc=C}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "C",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Dash_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{gc=Dash_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{gc=Dash_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{gc=Dash_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{gc=Dash_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{gc=Dash_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Dash_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Decimal_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{gc=Decimal_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{gc=Decimal_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{gc=Decimal_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{gc=Decimal_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{gc=Decimal_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Decimal_Number",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Enclosing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{gc=Enclosing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{gc=Enclosing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{gc=Enclosing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{gc=Enclosing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{gc=Enclosing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Enclosing_Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Final_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{gc=Final_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{gc=Final_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{gc=Final_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{gc=Final_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{gc=Final_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Final_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Format}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{gc=Format}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{gc=Format}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{gc=Format}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{gc=Format}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{gc=Format}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Format",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Initial_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{gc=Initial_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{gc=Initial_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{gc=Initial_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{gc=Initial_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{gc=Initial_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Initial_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=LC}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=LC}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=LC}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=LC}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=LC}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=LC}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "LC",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Letter_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{gc=Letter_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{gc=Letter_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{gc=Letter_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{gc=Letter_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{gc=Letter_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Letter_Number",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{gc=Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{gc=Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{gc=Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{gc=Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{gc=Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Line_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{gc=Line_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{gc=Line_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{gc=Line_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{gc=Line_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{gc=Line_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Line_Separator",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Ll}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Ll}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Ll}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Ll}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Ll}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Ll}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Ll",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Lm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Lm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Lm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Lm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Lm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Lm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Lm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Lowercase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{gc=Lowercase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{gc=Lowercase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{gc=Lowercase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{gc=Lowercase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{gc=Lowercase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Lowercase_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Lo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Lo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Lo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Lo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Lo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Lo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Lo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Lt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Lt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Lt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Lt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Lt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Lt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Lt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Lu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Lu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Lu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Lu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Lu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Lu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Lu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=L}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{gc=L}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{gc=L}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{gc=L}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{gc=L}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{gc=L}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "L",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{gc=Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{gc=Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{gc=Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{gc=Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{gc=Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Math_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{gc=Math_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{gc=Math_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{gc=Math_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{gc=Math_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{gc=Math_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Math_Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Mc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Mc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Mc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Mc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Mc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Mc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Mc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Me}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Me}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Me}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Me}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Me}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Me}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Me",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Mn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Mn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Mn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Mn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Mn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Mn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Mn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Modifier_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{gc=Modifier_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{gc=Modifier_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{gc=Modifier_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{gc=Modifier_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{gc=Modifier_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Modifier_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Modifier_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{gc=Modifier_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{gc=Modifier_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{gc=Modifier_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{gc=Modifier_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{gc=Modifier_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Modifier_Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=M}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{gc=M}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{gc=M}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{gc=M}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{gc=M}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{gc=M}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "M",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Nd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Nd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Nd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Nd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Nd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Nd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Nd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Nl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Nl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Nl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Nl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Nl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Nl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Nl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Nonspacing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{gc=Nonspacing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{gc=Nonspacing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{gc=Nonspacing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{gc=Nonspacing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{gc=Nonspacing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Nonspacing_Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=No}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=No}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=No}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=No}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=No}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=No}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "No",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{gc=Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{gc=Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{gc=Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{gc=Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{gc=Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Number",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=N}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{gc=N}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{gc=N}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{gc=N}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{gc=N}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{gc=N}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "N",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Open_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{gc=Open_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{gc=Open_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{gc=Open_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{gc=Open_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{gc=Open_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Open_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Other_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{gc=Other_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{gc=Other_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{gc=Other_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{gc=Other_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{gc=Other_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Other_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Other_Number}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{gc=Other_Number}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{gc=Other_Number}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{gc=Other_Number}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{gc=Other_Number}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{gc=Other_Number}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Other_Number",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Other_Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{gc=Other_Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{gc=Other_Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{gc=Other_Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{gc=Other_Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{gc=Other_Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Other_Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Other_Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{gc=Other_Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{gc=Other_Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{gc=Other_Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{gc=Other_Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{gc=Other_Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Other_Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Other}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{gc=Other}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{gc=Other}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{gc=Other}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{gc=Other}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{gc=Other}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Other",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Paragraph_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{gc=Paragraph_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{gc=Paragraph_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{gc=Paragraph_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{gc=Paragraph_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{gc=Paragraph_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Paragraph_Separator",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Pc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Pc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Pc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Pc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Pc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Pc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Pc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Pd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Pd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Pd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Pd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Pd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Pd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Pd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Pe}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Pe}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Pe}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Pe}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Pe}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Pe}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Pe",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Pf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Pf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Pf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Pf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Pf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Pf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Pf",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Pi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Pi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Pi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Pi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Pi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Pi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Pi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Po}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Po}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Po}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Po}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Po}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Po}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Po",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Private_Use}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{gc=Private_Use}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{gc=Private_Use}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{gc=Private_Use}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{gc=Private_Use}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{gc=Private_Use}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Private_Use",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Ps}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Ps}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Ps}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Ps}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Ps}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Ps}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Ps",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Punctuation}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{gc=Punctuation}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{gc=Punctuation}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{gc=Punctuation}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{gc=Punctuation}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{gc=Punctuation}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Punctuation",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=P}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{gc=P}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{gc=P}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{gc=P}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{gc=P}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{gc=P}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "P",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Sc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Sc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Sc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Sc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Sc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Sc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Sc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{gc=Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{gc=Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{gc=Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{gc=Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{gc=Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Separator",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Sk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Sk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Sk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Sk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Sk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Sk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Sk",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Sm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Sm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Sm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Sm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Sm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Sm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Sm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=So}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=So}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=So}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=So}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=So}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=So}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "So",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Space_Separator}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{gc=Space_Separator}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{gc=Space_Separator}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{gc=Space_Separator}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{gc=Space_Separator}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{gc=Space_Separator}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Space_Separator",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Spacing_Mark}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{gc=Spacing_Mark}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{gc=Spacing_Mark}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{gc=Spacing_Mark}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{gc=Spacing_Mark}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{gc=Spacing_Mark}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Spacing_Mark",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Surrogate}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{gc=Surrogate}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{gc=Surrogate}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{gc=Surrogate}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{gc=Surrogate}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{gc=Surrogate}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Surrogate",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Symbol}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{gc=Symbol}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{gc=Symbol}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{gc=Symbol}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{gc=Symbol}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{gc=Symbol}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Symbol",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=S}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{gc=S}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{gc=S}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{gc=S}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{gc=S}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{gc=S}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "S",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Titlecase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{gc=Titlecase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{gc=Titlecase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{gc=Titlecase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{gc=Titlecase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{gc=Titlecase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Titlecase_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Unassigned}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{gc=Unassigned}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{gc=Unassigned}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{gc=Unassigned}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{gc=Unassigned}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{gc=Unassigned}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Unassigned",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Uppercase_Letter}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{gc=Uppercase_Letter}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{gc=Uppercase_Letter}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{gc=Uppercase_Letter}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{gc=Uppercase_Letter}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{gc=Uppercase_Letter}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Uppercase_Letter",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Zl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Zl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Zl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Zl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Zl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Zl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Zl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Zp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Zp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Zp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Zp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Zp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Zp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Zp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Zs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{gc=Zs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{gc=Zs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{gc=Zs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{gc=Zs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{gc=Zs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Zs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=Z}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^\\p{gc=Z}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^\\p{gc=Z}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^\\p{gc=Z}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "\\p{gc=Z}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "\\p{gc=Z}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "Z",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=cntrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{gc=cntrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{gc=cntrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{gc=cntrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{gc=cntrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{gc=cntrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "cntrl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=digit}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{gc=digit}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{gc=digit}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{gc=digit}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{gc=digit}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{gc=digit}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "digit",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{gc=punct}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{gc=punct}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{gc=punct}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{gc=punct}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{gc=punct}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{gc=punct}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "gc",
+                    "value": "punct",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{punct}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{punct}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{punct}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{punct}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{punct}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{punct}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "General_Category",
+                    "value": "punct",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Adlam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Adlam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Adlam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Adlam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Adlam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Adlam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Adlam",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Adlm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Adlm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Adlm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Adlm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Adlm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Adlm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Adlm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Aghb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Aghb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Aghb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Aghb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Aghb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Aghb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Aghb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Ahom}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Ahom}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Ahom}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Ahom}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Ahom}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Ahom}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ahom",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Anatolian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{sc=Anatolian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{sc=Anatolian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{sc=Anatolian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{sc=Anatolian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{sc=Anatolian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Anatolian_Hieroglyphs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Arabic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Arabic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Arabic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Arabic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Arabic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Arabic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Arabic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Arab}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Arab}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Arab}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Arab}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Arab}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Arab}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Arab",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Armenian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Armenian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Armenian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Armenian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Armenian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Armenian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Armenian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Armi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Armi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Armi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Armi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Armi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Armi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Armi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Armn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Armn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Armn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Armn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Armn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Armn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Armn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Avestan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Avestan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Avestan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Avestan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Avestan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Avestan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Avestan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Avst}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Avst}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Avst}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Avst}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Avst}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Avst}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Avst",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Balinese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Balinese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Balinese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Balinese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Balinese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Balinese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Balinese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Bali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Bali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Bali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Bali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Bali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Bali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bali",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Bamum}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Bamum}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Bamum}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Bamum}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Bamum}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Bamum}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bamum",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Bamu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Bamu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Bamu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Bamu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Bamu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Bamu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bamu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Bassa_Vah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{sc=Bassa_Vah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{sc=Bassa_Vah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{sc=Bassa_Vah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{sc=Bassa_Vah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{sc=Bassa_Vah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bassa_Vah",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Bass}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Bass}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Bass}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Bass}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Bass}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Bass}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bass",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Batak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Batak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Batak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Batak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Batak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Batak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Batak",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Batk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Batk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Batk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Batk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Batk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Batk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Batk",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Bengali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Bengali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Bengali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Bengali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Bengali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Bengali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bengali",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Beng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Beng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Beng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Beng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Beng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Beng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Beng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Bhaiksuki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{sc=Bhaiksuki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{sc=Bhaiksuki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{sc=Bhaiksuki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{sc=Bhaiksuki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{sc=Bhaiksuki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bhaiksuki",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Bhks}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Bhks}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Bhks}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Bhks}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Bhks}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Bhks}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bhks",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Bopomofo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Bopomofo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Bopomofo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Bopomofo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Bopomofo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Bopomofo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bopomofo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Bopo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Bopo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Bopo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Bopo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Bopo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Bopo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bopo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Brahmi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Brahmi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Brahmi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Brahmi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Brahmi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Brahmi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Brahmi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Brah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Brah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Brah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Brah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Brah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Brah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Brah",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Braille}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Braille}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Braille}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Braille}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Braille}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Braille}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Braille",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Brai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Brai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Brai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Brai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Brai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Brai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Brai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Buginese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Buginese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Buginese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Buginese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Buginese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Buginese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Buginese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Bugi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Bugi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Bugi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Bugi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Bugi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Bugi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Bugi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Buhd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Buhd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Buhd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Buhd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Buhd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Buhd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Buhd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Buhid}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Buhid}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Buhid}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Buhid}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Buhid}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Buhid}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Buhid",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Cakm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Cakm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Cakm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Cakm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Cakm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Cakm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cakm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Canadian_Aboriginal}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{sc=Canadian_Aboriginal}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{sc=Canadian_Aboriginal}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{sc=Canadian_Aboriginal}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{sc=Canadian_Aboriginal}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{sc=Canadian_Aboriginal}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Canadian_Aboriginal",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Cans}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Cans}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Cans}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Cans}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Cans}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Cans}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cans",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Carian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Carian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Carian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Carian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Carian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Carian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Carian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Cari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Cari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Cari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Cari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Cari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Cari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Caucasian_Albanian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\p{sc=Caucasian_Albanian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\p{sc=Caucasian_Albanian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\p{sc=Caucasian_Albanian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\p{sc=Caucasian_Albanian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\p{sc=Caucasian_Albanian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Caucasian_Albanian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Chakma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Chakma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Chakma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Chakma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Chakma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Chakma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Chakma",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Cham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Cham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Cham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Cham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Cham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Cham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Cherokee}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Cherokee}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Cherokee}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Cherokee}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Cherokee}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Cherokee}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cherokee",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Cher}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Cher}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Cher}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Cher}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Cher}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Cher}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cher",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Chorasmian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{sc=Chorasmian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{sc=Chorasmian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{sc=Chorasmian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{sc=Chorasmian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{sc=Chorasmian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Chorasmian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Chrs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Chrs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Chrs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Chrs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Chrs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Chrs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Chrs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Common}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Common}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Common}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Common}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Common}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Common}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Common",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Coptic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Coptic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Coptic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Coptic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Coptic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Coptic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Coptic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Copt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Copt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Copt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Copt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Copt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Copt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Copt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Cpmn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Cpmn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Cpmn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Cpmn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Cpmn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Cpmn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cpmn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Cprt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Cprt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Cprt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Cprt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Cprt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Cprt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cprt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Cuneiform}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{sc=Cuneiform}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{sc=Cuneiform}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{sc=Cuneiform}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{sc=Cuneiform}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{sc=Cuneiform}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cuneiform",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Cypriot}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Cypriot}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Cypriot}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Cypriot}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Cypriot}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Cypriot}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cypriot",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Cypro_Minoan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{sc=Cypro_Minoan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{sc=Cypro_Minoan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{sc=Cypro_Minoan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{sc=Cypro_Minoan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{sc=Cypro_Minoan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cypro_Minoan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Cyrillic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Cyrillic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Cyrillic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Cyrillic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Cyrillic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Cyrillic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cyrillic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Cyrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Cyrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Cyrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Cyrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Cyrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Cyrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Cyrl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Deseret}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Deseret}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Deseret}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Deseret}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Deseret}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Deseret}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Deseret",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Devanagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{sc=Devanagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{sc=Devanagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{sc=Devanagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{sc=Devanagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{sc=Devanagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Devanagari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Deva}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Deva}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Deva}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Deva}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Deva}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Deva}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Deva",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Diak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Diak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Diak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Diak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Diak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Diak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Diak",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Dives_Akuru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{sc=Dives_Akuru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{sc=Dives_Akuru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{sc=Dives_Akuru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{sc=Dives_Akuru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{sc=Dives_Akuru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Dives_Akuru",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Dogra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Dogra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Dogra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Dogra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Dogra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Dogra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Dogra",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Dogr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Dogr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Dogr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Dogr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Dogr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Dogr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Dogr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Dsrt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Dsrt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Dsrt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Dsrt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Dsrt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Dsrt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Dsrt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Duployan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Duployan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Duployan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Duployan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Duployan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Duployan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Duployan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Dupl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Dupl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Dupl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Dupl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Dupl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Dupl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Dupl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Egyptian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{sc=Egyptian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{sc=Egyptian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{sc=Egyptian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{sc=Egyptian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{sc=Egyptian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Egyptian_Hieroglyphs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Egyp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Egyp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Egyp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Egyp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Egyp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Egyp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Egyp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Elbasan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Elbasan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Elbasan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Elbasan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Elbasan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Elbasan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Elbasan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Elba}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Elba}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Elba}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Elba}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Elba}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Elba}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Elba",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Elymaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Elymaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Elymaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Elymaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Elymaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Elymaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Elymaic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Elym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Elym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Elym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Elym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Elym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Elym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Elym",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Ethiopic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Ethiopic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Ethiopic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Ethiopic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Ethiopic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Ethiopic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ethiopic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Ethi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Ethi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Ethi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Ethi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Ethi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Ethi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ethi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Georgian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Georgian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Georgian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Georgian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Georgian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Georgian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Georgian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Geor}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Geor}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Geor}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Geor}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Geor}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Geor}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Geor",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Glagolitic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{sc=Glagolitic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{sc=Glagolitic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{sc=Glagolitic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{sc=Glagolitic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{sc=Glagolitic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Glagolitic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Glag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Glag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Glag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Glag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Glag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Glag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Glag",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Gong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Gong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Gong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Gong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Gong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Gong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Gonm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Gonm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Gonm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Gonm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Gonm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Gonm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gonm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Gothic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Gothic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Gothic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Gothic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Gothic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Gothic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gothic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Goth}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Goth}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Goth}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Goth}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Goth}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Goth}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Goth",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Grantha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Grantha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Grantha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Grantha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Grantha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Grantha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Grantha",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Gran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Gran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Gran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Gran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Gran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Gran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gran",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Greek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Greek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Greek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Greek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Greek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Greek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Greek",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Grek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Grek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Grek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Grek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Grek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Grek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Grek",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Gujarati}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Gujarati}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Gujarati}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Gujarati}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Gujarati}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Gujarati}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gujarati",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Gujr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Gujr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Gujr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Gujr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Gujr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Gujr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gujr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Gunjala_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{sc=Gunjala_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{sc=Gunjala_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{sc=Gunjala_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{sc=Gunjala_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{sc=Gunjala_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gunjala_Gondi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Gurmukhi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Gurmukhi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Gurmukhi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Gurmukhi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Gurmukhi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Gurmukhi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Gurmukhi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Guru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Guru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Guru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Guru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Guru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Guru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Guru",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hangul}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Hangul}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Hangul}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Hangul}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Hangul}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Hangul}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hangul",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Hang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Hang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Hang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Hang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Hang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hang",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hanifi_Rohingya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{sc=Hanifi_Rohingya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{sc=Hanifi_Rohingya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{sc=Hanifi_Rohingya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{sc=Hanifi_Rohingya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{sc=Hanifi_Rohingya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hanifi_Rohingya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Hani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Hani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Hani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Hani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Hani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hano}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Hano}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Hano}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Hano}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Hano}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Hano}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hano",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hanunoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Hanunoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Hanunoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Hanunoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Hanunoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Hanunoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hanunoo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Han}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{sc=Han}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{sc=Han}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{sc=Han}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{sc=Han}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{sc=Han}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Han",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hatran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Hatran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Hatran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Hatran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Hatran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Hatran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hatran",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hatr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Hatr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Hatr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Hatr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Hatr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Hatr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hatr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hebrew}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Hebrew}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Hebrew}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Hebrew}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Hebrew}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Hebrew}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hebrew",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hebr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Hebr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Hebr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Hebr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Hebr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Hebr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hebr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hiragana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Hiragana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Hiragana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Hiragana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Hiragana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Hiragana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hiragana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hira}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Hira}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Hira}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Hira}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Hira}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Hira}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hira",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hluw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Hluw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Hluw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Hluw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Hluw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Hluw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hluw",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hmng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Hmng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Hmng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Hmng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Hmng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Hmng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hmng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hmnp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Hmnp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Hmnp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Hmnp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Hmnp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Hmnp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hmnp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Hung}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Hung}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Hung}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Hung}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Hung}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Hung}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Hung",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Imperial_Aramaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{sc=Imperial_Aramaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{sc=Imperial_Aramaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{sc=Imperial_Aramaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{sc=Imperial_Aramaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{sc=Imperial_Aramaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Imperial_Aramaic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Inherited}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{sc=Inherited}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{sc=Inherited}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{sc=Inherited}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{sc=Inherited}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{sc=Inherited}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Inherited",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Inscriptional_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{sc=Inscriptional_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{sc=Inscriptional_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{sc=Inscriptional_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{sc=Inscriptional_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{sc=Inscriptional_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Inscriptional_Pahlavi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Inscriptional_Parthian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{sc=Inscriptional_Parthian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{sc=Inscriptional_Parthian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{sc=Inscriptional_Parthian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{sc=Inscriptional_Parthian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{sc=Inscriptional_Parthian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Inscriptional_Parthian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Ital}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Ital}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Ital}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Ital}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Ital}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Ital}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ital",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Javanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Javanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Javanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Javanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Javanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Javanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Javanese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Java}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Java}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Java}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Java}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Java}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Java}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Java",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Kaithi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Kaithi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Kaithi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Kaithi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Kaithi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Kaithi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kaithi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Kali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Kali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Kali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Kali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Kali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Kali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kali",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Kana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Kana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Kana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Kana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Kana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Kana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Kannada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Kannada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Kannada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Kannada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Kannada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Kannada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kannada",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Katakana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Katakana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Katakana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Katakana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Katakana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Katakana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Katakana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Kawi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Kawi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Kawi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Kawi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Kawi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Kawi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kawi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Kayah_Li}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Kayah_Li}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Kayah_Li}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Kayah_Li}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Kayah_Li}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Kayah_Li}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kayah_Li",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Kharoshthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{sc=Kharoshthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{sc=Kharoshthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{sc=Kharoshthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{sc=Kharoshthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{sc=Kharoshthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kharoshthi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Khar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Khar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Khar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Khar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Khar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Khar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Khitan_Small_Script}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{sc=Khitan_Small_Script}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{sc=Khitan_Small_Script}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{sc=Khitan_Small_Script}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{sc=Khitan_Small_Script}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{sc=Khitan_Small_Script}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khitan_Small_Script",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Khmer}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Khmer}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Khmer}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Khmer}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Khmer}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Khmer}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khmer",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Khmr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Khmr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Khmr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Khmr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Khmr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Khmr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khmr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Khojki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Khojki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Khojki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Khojki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Khojki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Khojki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khojki",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Khoj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Khoj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Khoj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Khoj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Khoj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Khoj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khoj",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Khudawadi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{sc=Khudawadi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{sc=Khudawadi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{sc=Khudawadi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{sc=Khudawadi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{sc=Khudawadi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Khudawadi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Kits}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Kits}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Kits}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Kits}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Kits}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Kits}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kits",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Knda}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Knda}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Knda}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Knda}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Knda}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Knda}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Knda",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Kthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Kthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Kthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Kthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Kthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Kthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Kthi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Lana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Lana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Lana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Lana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Lana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Lana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Laoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Laoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Laoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Laoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Laoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Laoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Laoo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Lao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{sc=Lao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{sc=Lao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{sc=Lao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{sc=Lao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{sc=Lao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lao",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Latin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Latin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Latin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Latin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Latin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Latin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Latin",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Latn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Latn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Latn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Latn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Latn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Latn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Latn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Lepcha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Lepcha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Lepcha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Lepcha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Lepcha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Lepcha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lepcha",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Lepc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Lepc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Lepc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Lepc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Lepc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Lepc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lepc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Limbu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Limbu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Limbu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Limbu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Limbu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Limbu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Limbu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Limb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Limb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Limb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Limb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Limb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Limb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Limb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Lina}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Lina}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Lina}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Lina}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Lina}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Lina}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lina",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Linb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Linb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Linb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Linb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Linb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Linb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Linb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Linear_A}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Linear_A}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Linear_A}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Linear_A}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Linear_A}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Linear_A}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Linear_A",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Linear_B}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Linear_B}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Linear_B}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Linear_B}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Linear_B}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Linear_B}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Linear_B",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Lisu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Lisu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Lisu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Lisu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Lisu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Lisu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lisu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Lycian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Lycian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Lycian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Lycian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Lycian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Lycian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lycian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Lyci}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Lyci}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Lyci}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Lyci}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Lyci}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Lyci}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lyci",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Lydian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Lydian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Lydian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Lydian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Lydian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Lydian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lydian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Lydi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Lydi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Lydi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Lydi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Lydi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Lydi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Lydi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mahajani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Mahajani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Mahajani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Mahajani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Mahajani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Mahajani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mahajani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mahj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Mahj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Mahj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Mahj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Mahj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Mahj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mahj",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Makasar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Makasar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Makasar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Makasar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Makasar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Makasar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Makasar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Maka}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Maka}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Maka}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Maka}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Maka}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Maka}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Maka",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Malayalam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{sc=Malayalam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{sc=Malayalam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{sc=Malayalam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{sc=Malayalam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{sc=Malayalam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Malayalam",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mandaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Mandaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Mandaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Mandaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Mandaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Mandaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mandaic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Mand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Mand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Mand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Mand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Mand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mand",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Manichaean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{sc=Manichaean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{sc=Manichaean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{sc=Manichaean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{sc=Manichaean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{sc=Manichaean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Manichaean",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Mani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Mani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Mani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Mani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Mani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Marchen}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Marchen}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Marchen}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Marchen}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Marchen}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Marchen}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Marchen",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Marc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Marc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Marc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Marc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Marc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Marc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Marc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Masaram_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{sc=Masaram_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{sc=Masaram_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{sc=Masaram_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{sc=Masaram_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{sc=Masaram_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Masaram_Gondi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Medefaidrin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{sc=Medefaidrin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{sc=Medefaidrin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{sc=Medefaidrin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{sc=Medefaidrin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{sc=Medefaidrin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Medefaidrin",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Medf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Medf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Medf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Medf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Medf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Medf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Medf",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Meetei_Mayek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{sc=Meetei_Mayek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{sc=Meetei_Mayek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{sc=Meetei_Mayek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{sc=Meetei_Mayek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{sc=Meetei_Mayek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Meetei_Mayek",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mende_Kikakui}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{sc=Mende_Kikakui}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{sc=Mende_Kikakui}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{sc=Mende_Kikakui}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{sc=Mende_Kikakui}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{sc=Mende_Kikakui}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mende_Kikakui",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mend}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Mend}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Mend}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Mend}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Mend}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Mend}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mend",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Merc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Merc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Merc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Merc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Merc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Merc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Merc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Meroitic_Cursive}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{sc=Meroitic_Cursive}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{sc=Meroitic_Cursive}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{sc=Meroitic_Cursive}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{sc=Meroitic_Cursive}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{sc=Meroitic_Cursive}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Meroitic_Cursive",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Meroitic_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{sc=Meroitic_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{sc=Meroitic_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{sc=Meroitic_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{sc=Meroitic_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{sc=Meroitic_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Meroitic_Hieroglyphs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mero}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Mero}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Mero}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Mero}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Mero}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Mero}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mero",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Miao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Miao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Miao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Miao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Miao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Miao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Miao",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mlym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Mlym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Mlym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Mlym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Mlym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Mlym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mlym",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Modi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Modi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Modi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Modi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Modi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Modi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Modi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mongolian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{sc=Mongolian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{sc=Mongolian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{sc=Mongolian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{sc=Mongolian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{sc=Mongolian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mongolian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Mong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Mong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Mong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Mong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Mong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mroo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Mroo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Mroo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Mroo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Mroo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Mroo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mroo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mro}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{sc=Mro}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{sc=Mro}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{sc=Mro}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{sc=Mro}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{sc=Mro}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mro",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mtei}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Mtei}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Mtei}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Mtei}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Mtei}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Mtei}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mtei",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Multani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Multani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Multani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Multani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Multani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Multani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Multani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mult}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Mult}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Mult}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Mult}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Mult}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Mult}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mult",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Myanmar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Myanmar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Myanmar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Myanmar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Myanmar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Myanmar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Myanmar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Mymr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Mymr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Mymr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Mymr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Mymr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Mymr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Mymr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Nabataean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{sc=Nabataean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{sc=Nabataean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{sc=Nabataean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{sc=Nabataean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{sc=Nabataean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nabataean",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Nag_Mundari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{sc=Nag_Mundari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{sc=Nag_Mundari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{sc=Nag_Mundari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{sc=Nag_Mundari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{sc=Nag_Mundari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nag_Mundari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Nagm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Nagm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Nagm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Nagm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Nagm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Nagm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nagm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Nandinagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{sc=Nandinagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{sc=Nandinagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{sc=Nandinagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{sc=Nandinagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{sc=Nandinagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nandinagari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Nand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Nand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Nand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Nand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Nand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Nand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nand",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Narb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Narb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Narb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Narb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Narb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Narb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Narb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Nbat}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Nbat}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Nbat}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Nbat}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Nbat}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Nbat}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nbat",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=New_Tai_Lue}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{sc=New_Tai_Lue}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{sc=New_Tai_Lue}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{sc=New_Tai_Lue}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{sc=New_Tai_Lue}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{sc=New_Tai_Lue}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "New_Tai_Lue",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Newa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Newa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Newa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Newa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Newa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Newa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Newa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Nkoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Nkoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Nkoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Nkoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Nkoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Nkoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nkoo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Nko}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{sc=Nko}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{sc=Nko}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{sc=Nko}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{sc=Nko}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{sc=Nko}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nko",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Nshu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Nshu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Nshu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Nshu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Nshu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Nshu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nshu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Nushu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Nushu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Nushu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Nushu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Nushu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Nushu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nushu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Nyiakeng_Puachue_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{sc=Nyiakeng_Puachue_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{sc=Nyiakeng_Puachue_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{sc=Nyiakeng_Puachue_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{sc=Nyiakeng_Puachue_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{sc=Nyiakeng_Puachue_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Nyiakeng_Puachue_Hmong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Ogam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Ogam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Ogam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Ogam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Ogam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Ogam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ogam",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Ogham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Ogham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Ogham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Ogham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Ogham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Ogham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ogham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Ol_Chiki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Ol_Chiki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Ol_Chiki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Ol_Chiki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Ol_Chiki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Ol_Chiki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ol_Chiki",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Olck}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Olck}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Olck}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Olck}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Olck}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Olck}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Olck",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Old_Hungarian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{sc=Old_Hungarian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{sc=Old_Hungarian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{sc=Old_Hungarian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{sc=Old_Hungarian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{sc=Old_Hungarian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Hungarian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Old_Italic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{sc=Old_Italic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{sc=Old_Italic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{sc=Old_Italic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{sc=Old_Italic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{sc=Old_Italic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Italic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Old_North_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{sc=Old_North_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{sc=Old_North_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{sc=Old_North_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{sc=Old_North_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{sc=Old_North_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_North_Arabian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Old_Permic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{sc=Old_Permic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{sc=Old_Permic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{sc=Old_Permic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{sc=Old_Permic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{sc=Old_Permic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Permic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Old_Persian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{sc=Old_Persian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{sc=Old_Persian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{sc=Old_Persian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{sc=Old_Persian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{sc=Old_Persian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Persian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Old_Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{sc=Old_Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{sc=Old_Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{sc=Old_Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{sc=Old_Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{sc=Old_Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Sogdian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Old_South_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{sc=Old_South_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{sc=Old_South_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{sc=Old_South_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{sc=Old_South_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{sc=Old_South_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_South_Arabian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Old_Turkic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{sc=Old_Turkic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{sc=Old_Turkic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{sc=Old_Turkic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{sc=Old_Turkic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{sc=Old_Turkic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Turkic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Old_Uyghur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{sc=Old_Uyghur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{sc=Old_Uyghur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{sc=Old_Uyghur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{sc=Old_Uyghur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{sc=Old_Uyghur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Old_Uyghur",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Oriya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Oriya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Oriya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Oriya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Oriya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Oriya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Oriya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Orkh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Orkh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Orkh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Orkh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Orkh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Orkh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Orkh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Orya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Orya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Orya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Orya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Orya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Orya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Orya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Osage}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Osage}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Osage}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Osage}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Osage}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Osage}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Osage",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Osge}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Osge}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Osge}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Osge}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Osge}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Osge}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Osge",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Osmanya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Osmanya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Osmanya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Osmanya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Osmanya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Osmanya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Osmanya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Osma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Osma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Osma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Osma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Osma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Osma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Osma",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Ougr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Ougr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Ougr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Ougr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Ougr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Ougr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ougr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Pahawh_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{sc=Pahawh_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{sc=Pahawh_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{sc=Pahawh_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{sc=Pahawh_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{sc=Pahawh_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Pahawh_Hmong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Palmyrene}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{sc=Palmyrene}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{sc=Palmyrene}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{sc=Palmyrene}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{sc=Palmyrene}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{sc=Palmyrene}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Palmyrene",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Palm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Palm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Palm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Palm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Palm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Palm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Palm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Pau_Cin_Hau}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{sc=Pau_Cin_Hau}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{sc=Pau_Cin_Hau}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{sc=Pau_Cin_Hau}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{sc=Pau_Cin_Hau}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{sc=Pau_Cin_Hau}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Pau_Cin_Hau",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Pauc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Pauc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Pauc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Pauc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Pauc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Pauc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Pauc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Perm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Perm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Perm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Perm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Perm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Perm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Perm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Phags_Pa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Phags_Pa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Phags_Pa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Phags_Pa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Phags_Pa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Phags_Pa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Phags_Pa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Phag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Phag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Phag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Phag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Phag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Phag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Phag",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Phli}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Phli}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Phli}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Phli}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Phli}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Phli}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Phli",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Phlp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Phlp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Phlp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Phlp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Phlp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Phlp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Phlp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Phnx}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Phnx}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Phnx}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Phnx}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Phnx}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Phnx}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Phnx",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Phoenician}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{sc=Phoenician}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{sc=Phoenician}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{sc=Phoenician}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{sc=Phoenician}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{sc=Phoenician}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Phoenician",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Plrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Plrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Plrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Plrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Plrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Plrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Plrd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Prti}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Prti}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Prti}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Prti}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Prti}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Prti}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Prti",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Psalter_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 28,
+        "raw": "/^\\p{sc=Psalter_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 26,
+          "raw": "^\\p{sc=Psalter_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 26,
+              "raw": "^\\p{sc=Psalter_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 25,
+                  "raw": "\\p{sc=Psalter_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 24,
+                    "raw": "\\p{sc=Psalter_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Psalter_Pahlavi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 25,
+                  "end": 26,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 27,
+          "end": 28,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Qaac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Qaac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Qaac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Qaac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Qaac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Qaac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Qaac",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Qaai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Qaai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Qaai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Qaai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Qaai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Qaai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Qaai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Rejang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Rejang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Rejang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Rejang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Rejang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Rejang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Rejang",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Rjng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Rjng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Rjng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Rjng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Rjng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Rjng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Rjng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Rohg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Rohg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Rohg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Rohg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Rohg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Rohg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Rohg",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Runic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Runic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Runic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Runic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Runic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Runic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Runic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Runr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Runr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Runr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Runr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Runr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Runr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Runr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Samaritan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{sc=Samaritan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{sc=Samaritan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{sc=Samaritan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{sc=Samaritan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{sc=Samaritan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Samaritan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Samr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Samr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Samr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Samr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Samr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Samr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Samr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sarb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Sarb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Sarb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Sarb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Sarb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Sarb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sarb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Saurashtra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{sc=Saurashtra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{sc=Saurashtra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{sc=Saurashtra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{sc=Saurashtra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{sc=Saurashtra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Saurashtra",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Saur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Saur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Saur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Saur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Saur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Saur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Saur",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sgnw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Sgnw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Sgnw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Sgnw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Sgnw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Sgnw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sgnw",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sharada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Sharada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Sharada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Sharada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Sharada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Sharada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sharada",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Shavian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Shavian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Shavian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Shavian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Shavian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Shavian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Shavian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Shaw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Shaw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Shaw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Shaw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Shaw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Shaw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Shaw",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Shrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Shrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Shrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Shrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Shrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Shrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Shrd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Siddham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Siddham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Siddham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Siddham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Siddham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Siddham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Siddham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sidd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Sidd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Sidd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Sidd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Sidd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Sidd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sidd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=SignWriting}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{sc=SignWriting}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{sc=SignWriting}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{sc=SignWriting}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{sc=SignWriting}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{sc=SignWriting}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "SignWriting",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sind}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Sind}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Sind}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Sind}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Sind}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Sind}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sind",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sinhala}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Sinhala}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Sinhala}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Sinhala}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Sinhala}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Sinhala}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sinhala",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Sinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Sinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Sinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Sinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Sinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sinh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sogdian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sogd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Sogd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Sogd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Sogd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Sogd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Sogd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sogd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sogo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Sogo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Sogo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Sogo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Sogo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Sogo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sogo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sora_Sompeng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{sc=Sora_Sompeng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{sc=Sora_Sompeng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{sc=Sora_Sompeng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{sc=Sora_Sompeng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{sc=Sora_Sompeng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sora_Sompeng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sora}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Sora}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Sora}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Sora}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Sora}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Sora}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sora",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Soyombo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Soyombo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Soyombo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Soyombo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Soyombo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Soyombo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Soyombo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Soyo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Soyo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Soyo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Soyo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Soyo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Soyo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Soyo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sundanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{sc=Sundanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{sc=Sundanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{sc=Sundanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{sc=Sundanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{sc=Sundanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sundanese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sund}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Sund}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Sund}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Sund}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Sund}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Sund}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sund",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Syloti_Nagri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{sc=Syloti_Nagri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{sc=Syloti_Nagri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{sc=Syloti_Nagri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{sc=Syloti_Nagri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{sc=Syloti_Nagri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Syloti_Nagri",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Sylo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Sylo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Sylo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Sylo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Sylo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Sylo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Sylo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Syrc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Syrc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Syrc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Syrc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Syrc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Syrc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Syrc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Syriac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Syriac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Syriac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Syriac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Syriac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Syriac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Syriac",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tagalog}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Tagalog}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Tagalog}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Tagalog}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Tagalog}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Tagalog}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tagalog",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tagbanwa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Tagbanwa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Tagbanwa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Tagbanwa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Tagbanwa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Tagbanwa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tagbanwa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tagb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Tagb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Tagb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Tagb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Tagb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Tagb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tagb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tai_Le}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Tai_Le}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Tai_Le}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Tai_Le}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Tai_Le}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Tai_Le}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tai_Le",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tai_Tham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Tai_Tham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Tai_Tham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Tai_Tham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Tai_Tham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Tai_Tham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tai_Tham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tai_Viet}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Tai_Viet}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Tai_Viet}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Tai_Viet}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Tai_Viet}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Tai_Viet}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tai_Viet",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Takri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Takri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Takri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Takri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Takri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Takri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Takri",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Takr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Takr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Takr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Takr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Takr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Takr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Takr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tale}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Tale}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Tale}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Tale}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Tale}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Tale}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tale",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Talu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Talu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Talu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Talu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Talu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Talu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Talu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tamil}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{sc=Tamil}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{sc=Tamil}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{sc=Tamil}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{sc=Tamil}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{sc=Tamil}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tamil",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Taml}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Taml}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Taml}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Taml}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Taml}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Taml}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Taml",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tangsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Tangsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Tangsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Tangsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Tangsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Tangsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tangsa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tangut}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Tangut}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Tangut}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Tangut}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Tangut}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Tangut}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tangut",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Tang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Tang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Tang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Tang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Tang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tang",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tavt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Tavt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Tavt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Tavt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Tavt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Tavt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tavt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Telugu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Telugu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Telugu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Telugu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Telugu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Telugu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Telugu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Telu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Telu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Telu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Telu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Telu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Telu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Telu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tfng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Tfng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Tfng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Tfng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Tfng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Tfng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tfng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tglg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Tglg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Tglg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Tglg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Tglg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Tglg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tglg",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Thaana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Thaana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Thaana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Thaana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Thaana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Thaana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Thaana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Thaa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Thaa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Thaa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Thaa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Thaa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Thaa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Thaa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Thai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Thai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Thai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Thai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Thai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Thai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Thai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tibetan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Tibetan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Tibetan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Tibetan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Tibetan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Tibetan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tibetan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tibt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Tibt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Tibt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Tibt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Tibt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Tibt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tibt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tifinagh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Tifinagh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Tifinagh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Tifinagh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Tifinagh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Tifinagh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tifinagh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tirhuta}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{sc=Tirhuta}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{sc=Tirhuta}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{sc=Tirhuta}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{sc=Tirhuta}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{sc=Tirhuta}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tirhuta",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tirh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Tirh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Tirh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Tirh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Tirh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Tirh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tirh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Tnsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Tnsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Tnsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Tnsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Tnsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Tnsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Tnsa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Toto}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Toto}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Toto}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Toto}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Toto}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Toto}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Toto",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Ugaritic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Ugaritic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Ugaritic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Ugaritic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Ugaritic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Ugaritic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ugaritic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Ugar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Ugar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Ugar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Ugar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Ugar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Ugar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Ugar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Vaii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Vaii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Vaii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Vaii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Vaii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Vaii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Vaii",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Vai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{sc=Vai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{sc=Vai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{sc=Vai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{sc=Vai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{sc=Vai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Vai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Vithkuqi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{sc=Vithkuqi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{sc=Vithkuqi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{sc=Vithkuqi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{sc=Vithkuqi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{sc=Vithkuqi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Vithkuqi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Vith}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Vith}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Vith}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Vith}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Vith}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Vith}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Vith",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Wancho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Wancho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Wancho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Wancho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Wancho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Wancho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Wancho",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Warang_Citi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{sc=Warang_Citi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{sc=Warang_Citi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{sc=Warang_Citi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{sc=Warang_Citi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{sc=Warang_Citi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Warang_Citi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Wara}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Wara}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Wara}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Wara}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Wara}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Wara}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Wara",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Wcho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Wcho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Wcho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Wcho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Wcho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Wcho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Wcho",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Xpeo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Xpeo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Xpeo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Xpeo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Xpeo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Xpeo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Xpeo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Xsux}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Xsux}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Xsux}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Xsux}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Xsux}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Xsux}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Xsux",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Yezidi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{sc=Yezidi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{sc=Yezidi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{sc=Yezidi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{sc=Yezidi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{sc=Yezidi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Yezidi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Yezi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Yezi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Yezi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Yezi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Yezi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Yezi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Yezi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Yiii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Yiii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Yiii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Yiii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Yiii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Yiii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Yiii",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Yi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{sc=Yi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{sc=Yi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{sc=Yi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{sc=Yi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{sc=Yi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Yi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Zanabazar_Square}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{sc=Zanabazar_Square}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{sc=Zanabazar_Square}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{sc=Zanabazar_Square}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{sc=Zanabazar_Square}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{sc=Zanabazar_Square}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Zanabazar_Square",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Zanb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Zanb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Zanb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Zanb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Zanb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Zanb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Zanb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Zinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Zinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Zinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Zinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Zinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Zinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Zinh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{sc=Zyyy}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{sc=Zyyy}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{sc=Zyyy}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{sc=Zyyy}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{sc=Zyyy}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{sc=Zyyy}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "sc",
+                    "value": "Zyyy",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Adlam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Adlam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Adlam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Adlam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Adlam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Adlam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Adlam",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Adlm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Adlm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Adlm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Adlm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Adlm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Adlm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Adlm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Aghb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Aghb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Aghb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Aghb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Aghb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Aghb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Aghb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Ahom}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Ahom}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Ahom}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Ahom}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Ahom}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Ahom}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ahom",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Anatolian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{scx=Anatolian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{scx=Anatolian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{scx=Anatolian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{scx=Anatolian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{scx=Anatolian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Anatolian_Hieroglyphs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Arabic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Arabic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Arabic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Arabic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Arabic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Arabic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Arabic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Arab}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Arab}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Arab}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Arab}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Arab}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Arab}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Arab",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Armenian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Armenian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Armenian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Armenian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Armenian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Armenian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Armenian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Armi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Armi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Armi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Armi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Armi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Armi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Armi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Armn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Armn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Armn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Armn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Armn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Armn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Armn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Avestan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Avestan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Avestan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Avestan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Avestan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Avestan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Avestan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Avst}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Avst}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Avst}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Avst}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Avst}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Avst}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Avst",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Balinese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Balinese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Balinese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Balinese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Balinese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Balinese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Balinese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Bali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Bali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Bali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Bali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Bali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Bali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bali",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Bamum}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Bamum}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Bamum}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Bamum}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Bamum}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Bamum}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bamum",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Bamu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Bamu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Bamu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Bamu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Bamu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Bamu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bamu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Bassa_Vah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{scx=Bassa_Vah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{scx=Bassa_Vah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{scx=Bassa_Vah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{scx=Bassa_Vah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{scx=Bassa_Vah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bassa_Vah",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Bass}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Bass}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Bass}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Bass}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Bass}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Bass}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bass",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Batak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Batak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Batak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Batak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Batak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Batak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Batak",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Batk}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Batk}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Batk}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Batk}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Batk}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Batk}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Batk",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Bengali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Bengali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Bengali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Bengali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Bengali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Bengali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bengali",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Beng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Beng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Beng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Beng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Beng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Beng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Beng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Bhaiksuki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{scx=Bhaiksuki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{scx=Bhaiksuki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{scx=Bhaiksuki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{scx=Bhaiksuki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{scx=Bhaiksuki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bhaiksuki",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Bhks}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Bhks}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Bhks}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Bhks}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Bhks}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Bhks}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bhks",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Bopomofo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Bopomofo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Bopomofo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Bopomofo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Bopomofo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Bopomofo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bopomofo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Bopo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Bopo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Bopo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Bopo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Bopo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Bopo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bopo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Brahmi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Brahmi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Brahmi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Brahmi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Brahmi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Brahmi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Brahmi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Brah}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Brah}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Brah}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Brah}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Brah}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Brah}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Brah",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Braille}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Braille}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Braille}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Braille}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Braille}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Braille}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Braille",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Brai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Brai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Brai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Brai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Brai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Brai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Brai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Buginese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Buginese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Buginese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Buginese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Buginese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Buginese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Buginese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Bugi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Bugi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Bugi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Bugi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Bugi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Bugi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Bugi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Buhd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Buhd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Buhd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Buhd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Buhd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Buhd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Buhd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Buhid}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Buhid}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Buhid}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Buhid}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Buhid}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Buhid}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Buhid",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Cakm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Cakm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Cakm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Cakm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Cakm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Cakm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cakm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Canadian_Aboriginal}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{scx=Canadian_Aboriginal}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{scx=Canadian_Aboriginal}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{scx=Canadian_Aboriginal}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{scx=Canadian_Aboriginal}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{scx=Canadian_Aboriginal}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Canadian_Aboriginal",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Cans}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Cans}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Cans}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Cans}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Cans}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Cans}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cans",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Carian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Carian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Carian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Carian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Carian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Carian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Carian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Cari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Cari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Cari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Cari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Cari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Cari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Caucasian_Albanian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^\\p{scx=Caucasian_Albanian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^\\p{scx=Caucasian_Albanian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^\\p{scx=Caucasian_Albanian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "\\p{scx=Caucasian_Albanian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "\\p{scx=Caucasian_Albanian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Caucasian_Albanian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Chakma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Chakma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Chakma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Chakma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Chakma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Chakma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Chakma",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Cham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Cham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Cham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Cham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Cham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Cham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Cherokee}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Cherokee}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Cherokee}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Cherokee}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Cherokee}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Cherokee}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cherokee",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Cher}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Cher}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Cher}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Cher}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Cher}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Cher}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cher",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Chorasmian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{scx=Chorasmian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{scx=Chorasmian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{scx=Chorasmian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{scx=Chorasmian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{scx=Chorasmian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Chorasmian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Chrs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Chrs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Chrs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Chrs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Chrs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Chrs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Chrs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Common}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Common}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Common}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Common}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Common}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Common}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Common",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Coptic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Coptic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Coptic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Coptic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Coptic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Coptic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Coptic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Copt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Copt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Copt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Copt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Copt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Copt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Copt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Cpmn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Cpmn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Cpmn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Cpmn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Cpmn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Cpmn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cpmn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Cprt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Cprt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Cprt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Cprt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Cprt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Cprt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cprt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Cuneiform}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{scx=Cuneiform}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{scx=Cuneiform}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{scx=Cuneiform}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{scx=Cuneiform}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{scx=Cuneiform}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cuneiform",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Cypriot}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Cypriot}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Cypriot}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Cypriot}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Cypriot}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Cypriot}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cypriot",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Cypro_Minoan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{scx=Cypro_Minoan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{scx=Cypro_Minoan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{scx=Cypro_Minoan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{scx=Cypro_Minoan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{scx=Cypro_Minoan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cypro_Minoan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Cyrillic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Cyrillic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Cyrillic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Cyrillic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Cyrillic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Cyrillic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cyrillic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Cyrl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Cyrl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Cyrl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Cyrl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Cyrl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Cyrl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Cyrl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Deseret}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Deseret}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Deseret}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Deseret}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Deseret}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Deseret}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Deseret",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Devanagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{scx=Devanagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{scx=Devanagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{scx=Devanagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{scx=Devanagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{scx=Devanagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Devanagari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Deva}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Deva}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Deva}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Deva}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Deva}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Deva}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Deva",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Diak}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Diak}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Diak}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Diak}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Diak}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Diak}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Diak",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Dives_Akuru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{scx=Dives_Akuru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{scx=Dives_Akuru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{scx=Dives_Akuru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{scx=Dives_Akuru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{scx=Dives_Akuru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Dives_Akuru",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Dogra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Dogra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Dogra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Dogra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Dogra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Dogra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Dogra",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Dogr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Dogr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Dogr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Dogr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Dogr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Dogr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Dogr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Dsrt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Dsrt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Dsrt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Dsrt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Dsrt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Dsrt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Dsrt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Duployan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Duployan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Duployan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Duployan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Duployan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Duployan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Duployan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Dupl}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Dupl}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Dupl}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Dupl}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Dupl}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Dupl}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Dupl",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Egyptian_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{scx=Egyptian_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{scx=Egyptian_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{scx=Egyptian_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{scx=Egyptian_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{scx=Egyptian_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Egyptian_Hieroglyphs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Egyp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Egyp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Egyp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Egyp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Egyp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Egyp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Egyp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Elbasan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Elbasan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Elbasan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Elbasan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Elbasan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Elbasan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Elbasan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Elba}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Elba}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Elba}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Elba}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Elba}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Elba}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Elba",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Elymaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Elymaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Elymaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Elymaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Elymaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Elymaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Elymaic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Elym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Elym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Elym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Elym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Elym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Elym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Elym",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Ethiopic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Ethiopic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Ethiopic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Ethiopic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Ethiopic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Ethiopic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ethiopic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Ethi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Ethi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Ethi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Ethi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Ethi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Ethi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ethi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Georgian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Georgian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Georgian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Georgian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Georgian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Georgian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Georgian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Geor}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Geor}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Geor}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Geor}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Geor}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Geor}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Geor",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Glagolitic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{scx=Glagolitic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{scx=Glagolitic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{scx=Glagolitic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{scx=Glagolitic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{scx=Glagolitic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Glagolitic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Glag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Glag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Glag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Glag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Glag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Glag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Glag",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Gong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Gong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Gong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Gong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Gong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Gong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Gonm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Gonm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Gonm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Gonm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Gonm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Gonm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gonm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Gothic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Gothic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Gothic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Gothic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Gothic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Gothic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gothic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Goth}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Goth}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Goth}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Goth}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Goth}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Goth}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Goth",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Grantha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Grantha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Grantha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Grantha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Grantha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Grantha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Grantha",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Gran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Gran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Gran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Gran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Gran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Gran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gran",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Greek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Greek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Greek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Greek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Greek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Greek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Greek",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Grek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Grek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Grek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Grek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Grek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Grek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Grek",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Gujarati}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Gujarati}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Gujarati}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Gujarati}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Gujarati}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Gujarati}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gujarati",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Gujr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Gujr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Gujr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Gujr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Gujr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Gujr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gujr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Gunjala_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{scx=Gunjala_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{scx=Gunjala_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{scx=Gunjala_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{scx=Gunjala_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{scx=Gunjala_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gunjala_Gondi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Gurmukhi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Gurmukhi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Gurmukhi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Gurmukhi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Gurmukhi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Gurmukhi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Gurmukhi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Guru}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Guru}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Guru}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Guru}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Guru}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Guru}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Guru",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hangul}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Hangul}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Hangul}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Hangul}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Hangul}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Hangul}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hangul",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Hang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Hang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Hang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Hang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Hang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hang",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hanifi_Rohingya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{scx=Hanifi_Rohingya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{scx=Hanifi_Rohingya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{scx=Hanifi_Rohingya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{scx=Hanifi_Rohingya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{scx=Hanifi_Rohingya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hanifi_Rohingya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Hani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Hani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Hani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Hani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Hani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hano}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Hano}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Hano}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Hano}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Hano}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Hano}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hano",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hanunoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Hanunoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Hanunoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Hanunoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Hanunoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Hanunoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hanunoo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Han}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{scx=Han}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{scx=Han}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{scx=Han}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{scx=Han}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{scx=Han}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Han",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hatran}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Hatran}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Hatran}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Hatran}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Hatran}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Hatran}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hatran",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hatr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Hatr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Hatr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Hatr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Hatr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Hatr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hatr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hebrew}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Hebrew}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Hebrew}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Hebrew}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Hebrew}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Hebrew}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hebrew",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hebr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Hebr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Hebr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Hebr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Hebr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Hebr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hebr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hiragana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Hiragana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Hiragana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Hiragana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Hiragana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Hiragana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hiragana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hira}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Hira}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Hira}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Hira}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Hira}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Hira}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hira",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hluw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Hluw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Hluw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Hluw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Hluw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Hluw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hluw",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hmng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Hmng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Hmng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Hmng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Hmng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Hmng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hmng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hmnp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Hmnp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Hmnp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Hmnp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Hmnp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Hmnp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hmnp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Hung}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Hung}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Hung}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Hung}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Hung}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Hung}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Hung",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Imperial_Aramaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{scx=Imperial_Aramaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{scx=Imperial_Aramaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{scx=Imperial_Aramaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{scx=Imperial_Aramaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{scx=Imperial_Aramaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Imperial_Aramaic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Inherited}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{scx=Inherited}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{scx=Inherited}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{scx=Inherited}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{scx=Inherited}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{scx=Inherited}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Inherited",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Inscriptional_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^\\p{scx=Inscriptional_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^\\p{scx=Inscriptional_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^\\p{scx=Inscriptional_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "\\p{scx=Inscriptional_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "\\p{scx=Inscriptional_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Inscriptional_Pahlavi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Inscriptional_Parthian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{scx=Inscriptional_Parthian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{scx=Inscriptional_Parthian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{scx=Inscriptional_Parthian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{scx=Inscriptional_Parthian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{scx=Inscriptional_Parthian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Inscriptional_Parthian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Ital}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Ital}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Ital}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Ital}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Ital}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Ital}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ital",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Javanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Javanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Javanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Javanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Javanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Javanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Javanese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Java}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Java}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Java}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Java}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Java}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Java}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Java",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Kaithi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Kaithi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Kaithi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Kaithi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Kaithi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Kaithi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kaithi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Kali}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Kali}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Kali}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Kali}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Kali}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Kali}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kali",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Kana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Kana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Kana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Kana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Kana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Kana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Kannada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Kannada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Kannada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Kannada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Kannada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Kannada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kannada",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Katakana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Katakana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Katakana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Katakana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Katakana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Katakana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Katakana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Kawi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Kawi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Kawi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Kawi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Kawi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Kawi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kawi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Kayah_Li}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Kayah_Li}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Kayah_Li}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Kayah_Li}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Kayah_Li}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Kayah_Li}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kayah_Li",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Kharoshthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{scx=Kharoshthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{scx=Kharoshthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{scx=Kharoshthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{scx=Kharoshthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{scx=Kharoshthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kharoshthi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Khar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Khar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Khar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Khar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Khar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Khar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Khitan_Small_Script}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^\\p{scx=Khitan_Small_Script}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^\\p{scx=Khitan_Small_Script}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^\\p{scx=Khitan_Small_Script}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "\\p{scx=Khitan_Small_Script}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "\\p{scx=Khitan_Small_Script}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khitan_Small_Script",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Khmer}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Khmer}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Khmer}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Khmer}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Khmer}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Khmer}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khmer",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Khmr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Khmr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Khmr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Khmr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Khmr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Khmr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khmr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Khojki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Khojki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Khojki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Khojki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Khojki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Khojki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khojki",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Khoj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Khoj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Khoj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Khoj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Khoj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Khoj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khoj",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Khudawadi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{scx=Khudawadi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{scx=Khudawadi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{scx=Khudawadi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{scx=Khudawadi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{scx=Khudawadi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Khudawadi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Kits}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Kits}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Kits}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Kits}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Kits}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Kits}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kits",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Knda}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Knda}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Knda}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Knda}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Knda}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Knda}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Knda",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Kthi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Kthi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Kthi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Kthi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Kthi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Kthi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Kthi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Lana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Lana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Lana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Lana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Lana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Lana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Laoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Laoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Laoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Laoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Laoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Laoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Laoo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Lao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{scx=Lao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{scx=Lao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{scx=Lao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{scx=Lao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{scx=Lao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lao",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Latin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Latin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Latin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Latin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Latin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Latin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Latin",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Latn}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Latn}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Latn}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Latn}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Latn}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Latn}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Latn",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Lepcha}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Lepcha}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Lepcha}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Lepcha}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Lepcha}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Lepcha}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lepcha",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Lepc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Lepc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Lepc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Lepc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Lepc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Lepc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lepc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Limbu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Limbu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Limbu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Limbu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Limbu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Limbu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Limbu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Limb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Limb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Limb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Limb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Limb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Limb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Limb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Lina}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Lina}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Lina}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Lina}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Lina}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Lina}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lina",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Linb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Linb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Linb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Linb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Linb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Linb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Linb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Linear_A}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Linear_A}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Linear_A}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Linear_A}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Linear_A}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Linear_A}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Linear_A",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Linear_B}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Linear_B}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Linear_B}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Linear_B}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Linear_B}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Linear_B}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Linear_B",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Lisu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Lisu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Lisu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Lisu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Lisu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Lisu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lisu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Lycian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Lycian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Lycian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Lycian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Lycian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Lycian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lycian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Lyci}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Lyci}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Lyci}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Lyci}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Lyci}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Lyci}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lyci",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Lydian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Lydian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Lydian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Lydian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Lydian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Lydian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lydian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Lydi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Lydi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Lydi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Lydi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Lydi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Lydi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Lydi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mahajani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Mahajani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Mahajani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Mahajani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Mahajani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Mahajani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mahajani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mahj}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Mahj}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Mahj}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Mahj}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Mahj}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Mahj}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mahj",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Makasar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Makasar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Makasar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Makasar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Makasar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Makasar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Makasar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Maka}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Maka}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Maka}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Maka}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Maka}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Maka}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Maka",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Malayalam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{scx=Malayalam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{scx=Malayalam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{scx=Malayalam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{scx=Malayalam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{scx=Malayalam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Malayalam",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mandaic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Mandaic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Mandaic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Mandaic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Mandaic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Mandaic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mandaic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Mand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Mand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Mand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Mand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Mand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mand",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Manichaean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{scx=Manichaean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{scx=Manichaean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{scx=Manichaean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{scx=Manichaean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{scx=Manichaean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Manichaean",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Mani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Mani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Mani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Mani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Mani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Marchen}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Marchen}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Marchen}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Marchen}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Marchen}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Marchen}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Marchen",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Marc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Marc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Marc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Marc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Marc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Marc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Marc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Masaram_Gondi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{scx=Masaram_Gondi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{scx=Masaram_Gondi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{scx=Masaram_Gondi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{scx=Masaram_Gondi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{scx=Masaram_Gondi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Masaram_Gondi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Medefaidrin}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{scx=Medefaidrin}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{scx=Medefaidrin}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{scx=Medefaidrin}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{scx=Medefaidrin}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{scx=Medefaidrin}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Medefaidrin",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Medf}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Medf}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Medf}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Medf}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Medf}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Medf}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Medf",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Meetei_Mayek}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{scx=Meetei_Mayek}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{scx=Meetei_Mayek}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{scx=Meetei_Mayek}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{scx=Meetei_Mayek}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{scx=Meetei_Mayek}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Meetei_Mayek",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mende_Kikakui}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{scx=Mende_Kikakui}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{scx=Mende_Kikakui}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{scx=Mende_Kikakui}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{scx=Mende_Kikakui}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{scx=Mende_Kikakui}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mende_Kikakui",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mend}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Mend}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Mend}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Mend}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Mend}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Mend}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mend",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Merc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Merc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Merc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Merc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Merc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Merc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Merc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Meroitic_Cursive}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{scx=Meroitic_Cursive}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{scx=Meroitic_Cursive}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{scx=Meroitic_Cursive}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{scx=Meroitic_Cursive}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{scx=Meroitic_Cursive}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Meroitic_Cursive",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Meroitic_Hieroglyphs}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^\\p{scx=Meroitic_Hieroglyphs}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^\\p{scx=Meroitic_Hieroglyphs}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^\\p{scx=Meroitic_Hieroglyphs}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "\\p{scx=Meroitic_Hieroglyphs}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "\\p{scx=Meroitic_Hieroglyphs}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Meroitic_Hieroglyphs",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mero}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Mero}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Mero}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Mero}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Mero}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Mero}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mero",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Miao}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Miao}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Miao}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Miao}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Miao}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Miao}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Miao",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mlym}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Mlym}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Mlym}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Mlym}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Mlym}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Mlym}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mlym",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Modi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Modi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Modi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Modi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Modi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Modi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Modi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mongolian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{scx=Mongolian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{scx=Mongolian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{scx=Mongolian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{scx=Mongolian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{scx=Mongolian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mongolian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Mong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Mong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Mong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Mong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Mong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mroo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Mroo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Mroo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Mroo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Mroo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Mroo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mroo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mro}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{scx=Mro}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{scx=Mro}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{scx=Mro}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{scx=Mro}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{scx=Mro}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mro",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mtei}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Mtei}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Mtei}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Mtei}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Mtei}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Mtei}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mtei",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Multani}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Multani}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Multani}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Multani}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Multani}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Multani}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Multani",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mult}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Mult}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Mult}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Mult}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Mult}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Mult}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mult",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Myanmar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Myanmar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Myanmar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Myanmar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Myanmar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Myanmar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Myanmar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Mymr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Mymr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Mymr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Mymr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Mymr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Mymr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Mymr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Nabataean}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{scx=Nabataean}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{scx=Nabataean}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{scx=Nabataean}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{scx=Nabataean}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{scx=Nabataean}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nabataean",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Nag_Mundari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{scx=Nag_Mundari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{scx=Nag_Mundari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{scx=Nag_Mundari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{scx=Nag_Mundari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{scx=Nag_Mundari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nag_Mundari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Nagm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Nagm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Nagm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Nagm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Nagm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Nagm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nagm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Nandinagari}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{scx=Nandinagari}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{scx=Nandinagari}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{scx=Nandinagari}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{scx=Nandinagari}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{scx=Nandinagari}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nandinagari",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Nand}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Nand}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Nand}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Nand}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Nand}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Nand}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nand",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Narb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Narb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Narb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Narb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Narb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Narb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Narb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Nbat}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Nbat}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Nbat}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Nbat}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Nbat}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Nbat}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nbat",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=New_Tai_Lue}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{scx=New_Tai_Lue}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{scx=New_Tai_Lue}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{scx=New_Tai_Lue}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{scx=New_Tai_Lue}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{scx=New_Tai_Lue}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "New_Tai_Lue",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Newa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Newa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Newa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Newa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Newa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Newa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Newa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Nkoo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Nkoo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Nkoo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Nkoo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Nkoo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Nkoo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nkoo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Nko}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{scx=Nko}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{scx=Nko}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{scx=Nko}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{scx=Nko}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{scx=Nko}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nko",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Nshu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Nshu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Nshu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Nshu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Nshu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Nshu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nshu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Nushu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Nushu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Nushu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Nushu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Nushu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Nushu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nushu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Nyiakeng_Puachue_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^\\p{scx=Nyiakeng_Puachue_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^\\p{scx=Nyiakeng_Puachue_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^\\p{scx=Nyiakeng_Puachue_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "\\p{scx=Nyiakeng_Puachue_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "\\p{scx=Nyiakeng_Puachue_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Nyiakeng_Puachue_Hmong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Ogam}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Ogam}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Ogam}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Ogam}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Ogam}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Ogam}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ogam",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Ogham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Ogham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Ogham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Ogham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Ogham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Ogham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ogham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Ol_Chiki}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Ol_Chiki}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Ol_Chiki}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Ol_Chiki}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Ol_Chiki}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Ol_Chiki}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ol_Chiki",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Olck}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Olck}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Olck}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Olck}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Olck}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Olck}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Olck",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Old_Hungarian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 27,
+        "raw": "/^\\p{scx=Old_Hungarian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 25,
+          "raw": "^\\p{scx=Old_Hungarian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 25,
+              "raw": "^\\p{scx=Old_Hungarian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 24,
+                  "raw": "\\p{scx=Old_Hungarian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 23,
+                    "raw": "\\p{scx=Old_Hungarian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Hungarian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 24,
+                  "end": 25,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 26,
+          "end": 27,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Old_Italic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{scx=Old_Italic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{scx=Old_Italic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{scx=Old_Italic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{scx=Old_Italic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{scx=Old_Italic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Italic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Old_North_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\p{scx=Old_North_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\p{scx=Old_North_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\p{scx=Old_North_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\p{scx=Old_North_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\p{scx=Old_North_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_North_Arabian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Old_Permic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{scx=Old_Permic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{scx=Old_Permic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{scx=Old_Permic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{scx=Old_Permic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{scx=Old_Permic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Permic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Old_Persian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{scx=Old_Persian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{scx=Old_Persian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{scx=Old_Persian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{scx=Old_Persian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{scx=Old_Persian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Persian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Old_Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{scx=Old_Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{scx=Old_Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{scx=Old_Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{scx=Old_Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{scx=Old_Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Sogdian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Old_South_Arabian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 31,
+        "raw": "/^\\p{scx=Old_South_Arabian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 29,
+          "raw": "^\\p{scx=Old_South_Arabian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 29,
+              "raw": "^\\p{scx=Old_South_Arabian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 28,
+                  "raw": "\\p{scx=Old_South_Arabian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 27,
+                    "raw": "\\p{scx=Old_South_Arabian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_South_Arabian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 28,
+                  "end": 29,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 30,
+          "end": 31,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Old_Turkic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{scx=Old_Turkic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{scx=Old_Turkic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{scx=Old_Turkic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{scx=Old_Turkic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{scx=Old_Turkic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Turkic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Old_Uyghur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{scx=Old_Uyghur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{scx=Old_Uyghur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{scx=Old_Uyghur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{scx=Old_Uyghur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{scx=Old_Uyghur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Old_Uyghur",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Oriya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Oriya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Oriya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Oriya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Oriya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Oriya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Oriya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Orkh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Orkh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Orkh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Orkh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Orkh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Orkh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Orkh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Orya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Orya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Orya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Orya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Orya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Orya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Orya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Osage}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Osage}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Osage}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Osage}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Osage}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Osage}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Osage",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Osge}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Osge}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Osge}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Osge}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Osge}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Osge}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Osge",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Osmanya}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Osmanya}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Osmanya}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Osmanya}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Osmanya}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Osmanya}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Osmanya",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Osma}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Osma}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Osma}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Osma}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Osma}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Osma}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Osma",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Ougr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Ougr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Ougr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Ougr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Ougr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Ougr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ougr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Pahawh_Hmong}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{scx=Pahawh_Hmong}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{scx=Pahawh_Hmong}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{scx=Pahawh_Hmong}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{scx=Pahawh_Hmong}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{scx=Pahawh_Hmong}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Pahawh_Hmong",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Palmyrene}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{scx=Palmyrene}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{scx=Palmyrene}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{scx=Palmyrene}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{scx=Palmyrene}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{scx=Palmyrene}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Palmyrene",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Palm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Palm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Palm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Palm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Palm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Palm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Palm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Pau_Cin_Hau}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{scx=Pau_Cin_Hau}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{scx=Pau_Cin_Hau}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{scx=Pau_Cin_Hau}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{scx=Pau_Cin_Hau}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{scx=Pau_Cin_Hau}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Pau_Cin_Hau",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Pauc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Pauc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Pauc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Pauc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Pauc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Pauc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Pauc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Perm}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Perm}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Perm}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Perm}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Perm}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Perm}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Perm",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Phags_Pa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Phags_Pa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Phags_Pa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Phags_Pa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Phags_Pa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Phags_Pa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Phags_Pa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Phag}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Phag}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Phag}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Phag}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Phag}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Phag}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Phag",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Phli}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Phli}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Phli}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Phli}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Phli}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Phli}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Phli",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Phlp}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Phlp}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Phlp}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Phlp}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Phlp}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Phlp}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Phlp",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Phnx}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Phnx}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Phnx}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Phnx}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Phnx}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Phnx}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Phnx",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Phoenician}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{scx=Phoenician}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{scx=Phoenician}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{scx=Phoenician}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{scx=Phoenician}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{scx=Phoenician}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Phoenician",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Plrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Plrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Plrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Plrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Plrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Plrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Plrd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Prti}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Prti}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Prti}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Prti}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Prti}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Prti}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Prti",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Psalter_Pahlavi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 29,
+        "raw": "/^\\p{scx=Psalter_Pahlavi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 27,
+          "raw": "^\\p{scx=Psalter_Pahlavi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 27,
+              "raw": "^\\p{scx=Psalter_Pahlavi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 26,
+                  "raw": "\\p{scx=Psalter_Pahlavi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 25,
+                    "raw": "\\p{scx=Psalter_Pahlavi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Psalter_Pahlavi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 26,
+                  "end": 27,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 28,
+          "end": 29,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Qaac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Qaac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Qaac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Qaac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Qaac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Qaac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Qaac",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Qaai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Qaai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Qaai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Qaai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Qaai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Qaai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Qaai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Rejang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Rejang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Rejang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Rejang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Rejang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Rejang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Rejang",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Rjng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Rjng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Rjng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Rjng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Rjng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Rjng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Rjng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Rohg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Rohg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Rohg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Rohg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Rohg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Rohg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Rohg",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Runic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Runic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Runic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Runic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Runic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Runic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Runic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Runr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Runr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Runr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Runr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Runr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Runr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Runr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Samaritan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{scx=Samaritan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{scx=Samaritan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{scx=Samaritan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{scx=Samaritan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{scx=Samaritan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Samaritan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Samr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Samr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Samr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Samr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Samr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Samr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Samr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sarb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Sarb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Sarb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Sarb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Sarb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Sarb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sarb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Saurashtra}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 24,
+        "raw": "/^\\p{scx=Saurashtra}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 22,
+          "raw": "^\\p{scx=Saurashtra}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 22,
+              "raw": "^\\p{scx=Saurashtra}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 21,
+                  "raw": "\\p{scx=Saurashtra}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 20,
+                    "raw": "\\p{scx=Saurashtra}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Saurashtra",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 21,
+                  "end": 22,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 23,
+          "end": 24,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Saur}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Saur}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Saur}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Saur}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Saur}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Saur}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Saur",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sgnw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Sgnw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Sgnw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Sgnw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Sgnw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Sgnw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sgnw",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sharada}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Sharada}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Sharada}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Sharada}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Sharada}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Sharada}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sharada",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Shavian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Shavian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Shavian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Shavian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Shavian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Shavian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Shavian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Shaw}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Shaw}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Shaw}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Shaw}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Shaw}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Shaw}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Shaw",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Shrd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Shrd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Shrd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Shrd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Shrd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Shrd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Shrd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Siddham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Siddham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Siddham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Siddham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Siddham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Siddham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Siddham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sidd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Sidd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Sidd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Sidd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Sidd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Sidd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sidd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=SignWriting}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{scx=SignWriting}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{scx=SignWriting}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{scx=SignWriting}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{scx=SignWriting}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{scx=SignWriting}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "SignWriting",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sind}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Sind}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Sind}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Sind}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Sind}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Sind}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sind",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sinhala}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Sinhala}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Sinhala}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Sinhala}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Sinhala}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Sinhala}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sinhala",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Sinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Sinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Sinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Sinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Sinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sinh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sogdian}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Sogdian}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Sogdian}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Sogdian}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Sogdian}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Sogdian}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sogdian",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sogd}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Sogd}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Sogd}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Sogd}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Sogd}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Sogd}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sogd",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sogo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Sogo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Sogo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Sogo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Sogo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Sogo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sogo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sora_Sompeng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{scx=Sora_Sompeng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{scx=Sora_Sompeng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{scx=Sora_Sompeng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{scx=Sora_Sompeng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{scx=Sora_Sompeng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sora_Sompeng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sora}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Sora}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Sora}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Sora}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Sora}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Sora}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sora",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Soyombo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Soyombo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Soyombo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Soyombo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Soyombo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Soyombo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Soyombo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Soyo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Soyo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Soyo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Soyo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Soyo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Soyo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Soyo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sundanese}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 23,
+        "raw": "/^\\p{scx=Sundanese}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 21,
+          "raw": "^\\p{scx=Sundanese}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 21,
+              "raw": "^\\p{scx=Sundanese}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 20,
+                  "raw": "\\p{scx=Sundanese}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 19,
+                    "raw": "\\p{scx=Sundanese}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sundanese",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 20,
+                  "end": 21,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 22,
+          "end": 23,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sund}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Sund}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Sund}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Sund}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Sund}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Sund}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sund",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Syloti_Nagri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 26,
+        "raw": "/^\\p{scx=Syloti_Nagri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 24,
+          "raw": "^\\p{scx=Syloti_Nagri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 24,
+              "raw": "^\\p{scx=Syloti_Nagri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 23,
+                  "raw": "\\p{scx=Syloti_Nagri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 22,
+                    "raw": "\\p{scx=Syloti_Nagri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Syloti_Nagri",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 23,
+                  "end": 24,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 25,
+          "end": 26,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Sylo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Sylo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Sylo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Sylo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Sylo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Sylo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Sylo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Syrc}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Syrc}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Syrc}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Syrc}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Syrc}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Syrc}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Syrc",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Syriac}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Syriac}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Syriac}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Syriac}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Syriac}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Syriac}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Syriac",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tagalog}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Tagalog}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Tagalog}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Tagalog}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Tagalog}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Tagalog}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tagalog",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tagbanwa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Tagbanwa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Tagbanwa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Tagbanwa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Tagbanwa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Tagbanwa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tagbanwa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tagb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Tagb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Tagb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Tagb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Tagb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Tagb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tagb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tai_Le}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Tai_Le}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Tai_Le}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Tai_Le}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Tai_Le}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Tai_Le}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tai_Le",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tai_Tham}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Tai_Tham}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Tai_Tham}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Tai_Tham}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Tai_Tham}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Tai_Tham}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tai_Tham",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tai_Viet}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Tai_Viet}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Tai_Viet}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Tai_Viet}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Tai_Viet}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Tai_Viet}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tai_Viet",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Takri}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Takri}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Takri}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Takri}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Takri}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Takri}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Takri",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Takr}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Takr}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Takr}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Takr}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Takr}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Takr}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Takr",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tale}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Tale}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Tale}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Tale}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Tale}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Tale}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tale",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Talu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Talu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Talu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Talu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Talu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Talu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Talu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tamil}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 19,
+        "raw": "/^\\p{scx=Tamil}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 17,
+          "raw": "^\\p{scx=Tamil}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 17,
+              "raw": "^\\p{scx=Tamil}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 16,
+                  "raw": "\\p{scx=Tamil}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 15,
+                    "raw": "\\p{scx=Tamil}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tamil",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 16,
+                  "end": 17,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 18,
+          "end": 19,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Taml}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Taml}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Taml}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Taml}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Taml}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Taml}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Taml",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tangsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Tangsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Tangsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Tangsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Tangsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Tangsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tangsa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tangut}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Tangut}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Tangut}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Tangut}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Tangut}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Tangut}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tangut",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tang}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Tang}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Tang}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Tang}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Tang}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Tang}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tang",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tavt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Tavt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Tavt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Tavt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Tavt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Tavt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tavt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Telugu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Telugu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Telugu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Telugu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Telugu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Telugu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Telugu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Telu}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Telu}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Telu}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Telu}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Telu}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Telu}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Telu",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tfng}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Tfng}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Tfng}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Tfng}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Tfng}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Tfng}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tfng",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tglg}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Tglg}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Tglg}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Tglg}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Tglg}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Tglg}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tglg",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Thaana}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Thaana}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Thaana}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Thaana}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Thaana}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Thaana}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Thaana",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Thaa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Thaa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Thaa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Thaa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Thaa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Thaa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Thaa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Thai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Thai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Thai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Thai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Thai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Thai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Thai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tibetan}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Tibetan}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Tibetan}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Tibetan}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Tibetan}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Tibetan}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tibetan",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tibt}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Tibt}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Tibt}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Tibt}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Tibt}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Tibt}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tibt",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tifinagh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Tifinagh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Tifinagh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Tifinagh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Tifinagh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Tifinagh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tifinagh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tirhuta}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 21,
+        "raw": "/^\\p{scx=Tirhuta}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 19,
+          "raw": "^\\p{scx=Tirhuta}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 19,
+              "raw": "^\\p{scx=Tirhuta}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 18,
+                  "raw": "\\p{scx=Tirhuta}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 17,
+                    "raw": "\\p{scx=Tirhuta}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tirhuta",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 18,
+                  "end": 19,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 20,
+          "end": 21,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tirh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Tirh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Tirh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Tirh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Tirh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Tirh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tirh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Tnsa}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Tnsa}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Tnsa}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Tnsa}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Tnsa}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Tnsa}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Tnsa",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Toto}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Toto}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Toto}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Toto}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Toto}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Toto}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Toto",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Ugaritic}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Ugaritic}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Ugaritic}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Ugaritic}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Ugaritic}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Ugaritic}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ugaritic",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Ugar}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Ugar}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Ugar}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Ugar}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Ugar}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Ugar}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Ugar",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Vaii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Vaii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Vaii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Vaii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Vaii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Vaii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Vaii",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Vai}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^\\p{scx=Vai}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^\\p{scx=Vai}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^\\p{scx=Vai}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "\\p{scx=Vai}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "\\p{scx=Vai}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Vai",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Vithkuqi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 22,
+        "raw": "/^\\p{scx=Vithkuqi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 20,
+          "raw": "^\\p{scx=Vithkuqi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 20,
+              "raw": "^\\p{scx=Vithkuqi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 19,
+                  "raw": "\\p{scx=Vithkuqi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 18,
+                    "raw": "\\p{scx=Vithkuqi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Vithkuqi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 19,
+                  "end": 20,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 21,
+          "end": 22,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Vith}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Vith}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Vith}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Vith}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Vith}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Vith}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Vith",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Wancho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Wancho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Wancho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Wancho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Wancho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Wancho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Wancho",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Warang_Citi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 25,
+        "raw": "/^\\p{scx=Warang_Citi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 23,
+          "raw": "^\\p{scx=Warang_Citi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 23,
+              "raw": "^\\p{scx=Warang_Citi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 22,
+                  "raw": "\\p{scx=Warang_Citi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 21,
+                    "raw": "\\p{scx=Warang_Citi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Warang_Citi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 22,
+                  "end": 23,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 24,
+          "end": 25,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Wara}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Wara}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Wara}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Wara}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Wara}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Wara}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Wara",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Wcho}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Wcho}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Wcho}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Wcho}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Wcho}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Wcho}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Wcho",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Xpeo}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Xpeo}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Xpeo}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Xpeo}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Xpeo}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Xpeo}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Xpeo",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Xsux}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Xsux}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Xsux}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Xsux}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Xsux}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Xsux}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Xsux",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Yezidi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^\\p{scx=Yezidi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^\\p{scx=Yezidi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^\\p{scx=Yezidi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "\\p{scx=Yezidi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "\\p{scx=Yezidi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Yezidi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Yezi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Yezi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Yezi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Yezi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Yezi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Yezi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Yezi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Yiii}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Yiii}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Yiii}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Yiii}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Yiii}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Yiii}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Yiii",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Yi}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^\\p{scx=Yi}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^\\p{scx=Yi}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^\\p{scx=Yi}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "\\p{scx=Yi}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "\\p{scx=Yi}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Yi",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Zanabazar_Square}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 30,
+        "raw": "/^\\p{scx=Zanabazar_Square}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 28,
+          "raw": "^\\p{scx=Zanabazar_Square}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 28,
+              "raw": "^\\p{scx=Zanabazar_Square}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 27,
+                  "raw": "\\p{scx=Zanabazar_Square}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 26,
+                    "raw": "\\p{scx=Zanabazar_Square}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Zanabazar_Square",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 27,
+                  "end": 28,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 29,
+          "end": 30,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Zanb}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Zanb}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Zanb}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Zanb}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Zanb}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Zanb}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Zanb",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Zinh}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Zinh}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Zinh}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Zinh}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Zinh}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Zinh}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Zinh",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{scx=Zyyy}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^\\p{scx=Zyyy}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^\\p{scx=Zyyy}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^\\p{scx=Zyyy}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "\\p{scx=Zyyy}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "\\p{scx=Zyyy}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "scx",
+                    "value": "Zyyy",
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^\\p{space}+$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^\\p{space}+$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^\\p{space}+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^\\p{space}+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "\\p{space}+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterSet",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "\\p{space}",
+                    "kind": "property",
+                    "strings": false,
+                    "key": "space",
+                    "value": null,
+                    "negate": false
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/regexp-v-flag.json b/test/fixtures/parser/literal/test262/regexp-v-flag.json
new file mode 100644
index 0000000..b56170e
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/regexp-v-flag.json
@@ -0,0 +1,7789 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/prototype/unicodeSets/this-val-regexp.js",
+    "test/built-ins/RegExp/prototype/unicodeSets/uv-flags.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-difference-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-difference-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-difference-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-difference-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-difference-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-difference-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-difference-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-difference-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-intersection-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-intersection-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-intersection-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-intersection-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-union-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-union-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-union-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-escape-union-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-intersection-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-intersection-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-intersection-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-intersection-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-union-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-union-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-union-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-class-union-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-difference-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-difference-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-difference-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-difference-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-intersection-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-intersection-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-intersection-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-intersection-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-union-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-union-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-union-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/character-union-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-difference-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-difference-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-difference-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-difference-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-intersection-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-intersection-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-intersection-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-intersection-string-literal.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-union-character-class-escape.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-union-character-class.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-union-character.js",
+    "test/built-ins/RegExp/unicodeSets/generated/string-literal-union-string-literal.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/./uv": {
+      "error": {
+        "message": "Invalid regular expression: /./uv: Invalid regular expression flags",
+        "index": 3
+      }
+    },
+    "/./v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 4,
+        "raw": "/./v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 4,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/./vd": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./vd",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "vd",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": true,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/./vg": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./vg",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "vg",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/./vi": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./vi",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "vi",
+          "global": false,
+          "ignoreCase": true,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/./vm": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./vm",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "vm",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/./vs": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./vs",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "vs",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": true,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/./vy": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/./vy",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": ".",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": ".",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": ".",
+                  "kind": "any"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 5,
+          "raw": "vy",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": true,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]&&[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^[[0-9]&&[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^[[0-9]&&[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^[[0-9]&&[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "[[0-9]&&[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "[[0-9]&&[0-9]]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 15,
+                      "raw": "[0-9]&&[0-9]",
+                      "left": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 15,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 11,
+                            "end": 14,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 13,
+                              "end": 14,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]&&\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^[[0-9]&&\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^[[0-9]&&\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^[[0-9]&&\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "[[0-9]&&\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "[[0-9]&&\\d]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 12,
+                      "raw": "[0-9]&&\\d",
+                      "left": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 12,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^[[0-9]&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^[[0-9]&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^[[0-9]&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "[[0-9]&&\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "[[0-9]&&\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 33,
+                      "raw": "[0-9]&&\\q{0|2|4|9\\uFE0F\\u20E3}",
+                      "left": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 33,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 13,
+                            "end": 14,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 14,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 15,
+                            "end": 16,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 15,
+                                "end": 16,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 17,
+                            "end": 18,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 17,
+                                "end": 18,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 19,
+                            "end": 32,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 20,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 20,
+                                "end": 26,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 26,
+                                "end": 32,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]&&_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^[[0-9]&&_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^[[0-9]&&_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^[[0-9]&&_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "[[0-9]&&_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "[[0-9]&&_]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 11,
+                      "raw": "[0-9]&&_",
+                      "left": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 11,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]--[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 20,
+        "raw": "/^[[0-9]--[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 18,
+          "raw": "^[[0-9]--[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 18,
+              "raw": "^[[0-9]--[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 17,
+                  "raw": "[[0-9]--[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 16,
+                    "raw": "[[0-9]--[0-9]]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 15,
+                      "raw": "[0-9]--[0-9]",
+                      "left": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 15,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 11,
+                            "end": 14,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 13,
+                              "end": 14,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 17,
+                  "end": 18,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 19,
+          "end": 20,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]--\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^[[0-9]--\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^[[0-9]--\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^[[0-9]--\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "[[0-9]--\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "[[0-9]--\\d]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 12,
+                      "raw": "[0-9]--\\d",
+                      "left": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 12,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]--\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^[[0-9]--\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^[[0-9]--\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^[[0-9]--\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "[[0-9]--\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "[[0-9]--\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 33,
+                      "raw": "[0-9]--\\q{0|2|4|9\\uFE0F\\u20E3}",
+                      "left": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 33,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 13,
+                            "end": 14,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 14,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 15,
+                            "end": 16,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 15,
+                                "end": 16,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 17,
+                            "end": 18,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 17,
+                                "end": 18,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 19,
+                            "end": 32,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 20,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 20,
+                                "end": 26,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 26,
+                                "end": 32,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]--_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^[[0-9]--_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^[[0-9]--_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^[[0-9]--_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "[[0-9]--_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "[[0-9]--_]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 11,
+                      "raw": "[0-9]--_",
+                      "left": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 10,
+                        "end": 11,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9][0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/^[[0-9][0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "^[[0-9][0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "^[[0-9][0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 15,
+                  "raw": "[[0-9][0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 14,
+                    "raw": "[[0-9][0-9]]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClass",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      {
+                        "type": "CharacterClass",
+                        "parent": "♻️../..",
+                        "start": 8,
+                        "end": 13,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 12,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 11,
+                              "end": 12,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 15,
+                  "end": 16,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^[[0-9]\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^[[0-9]\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^[[0-9]\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "[[0-9]\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "[[0-9]\\d]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClass",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 8,
+                        "end": 10,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^[[0-9]\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^[[0-9]\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^[[0-9]\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "[[0-9]\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "[[0-9]\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClass",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️../..",
+                        "start": 8,
+                        "end": 31,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 11,
+                            "end": 12,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 11,
+                                "end": 12,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 13,
+                            "end": 14,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 14,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 15,
+                            "end": 16,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 15,
+                                "end": 16,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 17,
+                            "end": 30,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 17,
+                                "end": 18,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 18,
+                                "end": 24,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 24,
+                                "end": 30,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[[0-9]_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^[[0-9]_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^[[0-9]_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^[[0-9]_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "[[0-9]_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "[[0-9]_]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterClass",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 8,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 4,
+                            "end": 7,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 4,
+                              "end": 5,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 8,
+                        "end": 9,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d&&[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^[\\d&&[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^[\\d&&[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^[\\d&&[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "[\\d&&[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "[\\d&&[0-9]]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 12,
+                      "raw": "\\d&&[0-9]",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 12,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 11,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 8,
+                              "end": 9,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 10,
+                              "end": 11,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d&&\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^[\\d&&\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^[\\d&&\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^[\\d&&\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "[\\d&&\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "[\\d&&\\d]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 9,
+                      "raw": "\\d&&\\d",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 9,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^[\\d&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^[\\d&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^[\\d&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "[\\d&&\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "[\\d&&\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 30,
+                      "raw": "\\d&&\\q{0|2|4|9\\uFE0F\\u20E3}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 30,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 13,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 14,
+                            "end": 15,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 14,
+                                "end": 15,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 16,
+                            "end": 29,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 16,
+                                "end": 17,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 17,
+                                "end": 23,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 23,
+                                "end": 29,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d&&_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^[\\d&&_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^[\\d&&_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^[\\d&&_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "[\\d&&_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "[\\d&&_]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 8,
+                      "raw": "\\d&&_",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 8,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d--[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 17,
+        "raw": "/^[\\d--[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 15,
+          "raw": "^[\\d--[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 15,
+              "raw": "^[\\d--[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 14,
+                  "raw": "[\\d--[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 13,
+                    "raw": "[\\d--[0-9]]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 12,
+                      "raw": "\\d--[0-9]",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 12,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 11,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 8,
+                              "end": 9,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 10,
+                              "end": 11,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 14,
+                  "end": 15,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 16,
+          "end": 17,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d--\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^[\\d--\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^[\\d--\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^[\\d--\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "[\\d--\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "[\\d--\\d]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 9,
+                      "raw": "\\d--\\d",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 9,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d--\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^[\\d--\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^[\\d--\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^[\\d--\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "[\\d--\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "[\\d--\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 30,
+                      "raw": "\\d--\\q{0|2|4|9\\uFE0F\\u20E3}",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 30,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 13,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 14,
+                            "end": 15,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 14,
+                                "end": 15,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 16,
+                            "end": 29,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 16,
+                                "end": 17,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 17,
+                                "end": 23,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 23,
+                                "end": 29,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d--_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^[\\d--_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^[\\d--_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^[\\d--_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "[\\d--_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "[\\d--_]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 8,
+                      "raw": "\\d--_",
+                      "left": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 7,
+                        "end": 8,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 15,
+        "raw": "/^[\\d[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 13,
+          "raw": "^[\\d[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 13,
+              "raw": "^[\\d[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 12,
+                  "raw": "[\\d[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 11,
+                    "raw": "[\\d[0-9]]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      {
+                        "type": "CharacterClass",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 10,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 9,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 6,
+                              "end": 7,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 8,
+                              "end": 9,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 12,
+                  "end": 13,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 14,
+          "end": 15,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^[\\d\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^[\\d\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^[\\d\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "[\\d\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "[\\d\\d]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 7,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^[\\d\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^[\\d\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^[\\d\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "[\\d\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "[\\d\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 28,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 13,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 14,
+                            "end": 27,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 14,
+                                "end": 15,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 15,
+                                "end": 21,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 21,
+                                "end": 27,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\d_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^[\\d_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^[\\d_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^[\\d_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "[\\d_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "[\\d_]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 5,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 5,
+                        "end": 6,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}&&[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}&&[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}&&[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}&&[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}&&[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}&&[0-9]]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 33,
+                      "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}&&[0-9]",
+                      "left": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 28,
+                        "end": 33,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 29,
+                            "end": 32,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 29,
+                              "end": 30,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 31,
+                              "end": 32,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\d]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 30,
+                      "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}&&\\d",
+                      "left": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 28,
+                        "end": 30,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 56,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 54,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 54,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 53,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 52,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}&&\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 51,
+                      "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}&&\\q{0|2|4|9\\uFE0F\\u20E3}",
+                      "left": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 28,
+                        "end": 51,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 31,
+                            "end": 32,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 31,
+                                "end": 32,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 33,
+                            "end": 34,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 33,
+                                "end": 34,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 35,
+                            "end": 36,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 35,
+                                "end": 36,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 37,
+                            "end": 50,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 37,
+                                "end": 38,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 38,
+                                "end": 44,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 44,
+                                "end": 50,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 53,
+                  "end": 54,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 55,
+          "end": 56,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}&&_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}&&_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}&&_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}&&_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}&&_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}&&_]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 29,
+                      "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}&&_",
+                      "left": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 28,
+                        "end": 29,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}--[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 38,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}--[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 36,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}--[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 36,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}--[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 35,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}--[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 34,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}--[0-9]]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 33,
+                      "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}--[0-9]",
+                      "left": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 28,
+                        "end": 33,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 29,
+                            "end": 32,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 29,
+                              "end": 30,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 31,
+                              "end": 32,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 35,
+                  "end": 36,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 37,
+          "end": 38,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 35,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 33,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 33,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 32,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}--\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 31,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}--\\d]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 30,
+                      "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}--\\d",
+                      "left": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 28,
+                        "end": 30,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 32,
+                  "end": 33,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 34,
+          "end": 35,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 56,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 54,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 54,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}--\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 53,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}--\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 52,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}--\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 51,
+                      "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}--\\q{0|2|4|9\\uFE0F\\u20E3}",
+                      "left": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 28,
+                        "end": 51,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 31,
+                            "end": 32,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 31,
+                                "end": 32,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 33,
+                            "end": 34,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 33,
+                                "end": 34,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 35,
+                            "end": 36,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 35,
+                                "end": 36,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 37,
+                            "end": 50,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 37,
+                                "end": 38,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 38,
+                                "end": 44,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 44,
+                                "end": 50,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 53,
+                  "end": 54,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 55,
+          "end": 56,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}--_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}--_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}--_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}--_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}--_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}--_]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 29,
+                      "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}--_",
+                      "left": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 28,
+                        "end": 29,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 36,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 34,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 34,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 33,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 32,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}[0-9]]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      {
+                        "type": "CharacterClass",
+                        "parent": "♻️../..",
+                        "start": 26,
+                        "end": 31,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 27,
+                            "end": 30,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 27,
+                              "end": 28,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 29,
+                              "end": 30,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 33,
+                  "end": 34,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 35,
+          "end": 36,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 33,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 31,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 31,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 30,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 29,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}\\d]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 26,
+                        "end": 28,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 30,
+                  "end": 31,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 32,
+          "end": 33,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 54,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 52,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 52,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 51,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 50,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️../..",
+                        "start": 26,
+                        "end": 49,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 29,
+                            "end": 30,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 29,
+                                "end": 30,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 31,
+                            "end": 32,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 31,
+                                "end": 32,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 33,
+                            "end": 34,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 33,
+                                "end": 34,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 35,
+                            "end": 48,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 35,
+                                "end": 36,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 36,
+                                "end": 42,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 42,
+                                "end": 48,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 51,
+                  "end": 52,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 53,
+          "end": 54,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[\\q{0|2|4|9\\uFE0F\\u20E3}_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^[\\q{0|2|4|9\\uFE0F\\u20E3}_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^[\\q{0|2|4|9\\uFE0F\\u20E3}_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "[\\q{0|2|4|9\\uFE0F\\u20E3}_]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 26,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 6,
+                            "end": 7,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 6,
+                                "end": 7,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 8,
+                            "end": 9,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 8,
+                                "end": 9,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 10,
+                            "end": 11,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 10,
+                                "end": 11,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 12,
+                            "end": 25,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 12,
+                                "end": 13,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 19,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 19,
+                                "end": 25,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 26,
+                        "end": 27,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_&&[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^[_&&[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^[_&&[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^[_&&[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "[_&&[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "[_&&[0-9]]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 11,
+                      "raw": "_&&[0-9]",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      "right": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 11,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 7,
+                            "end": 10,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_&&\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^[_&&\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^[_&&\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^[_&&\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "[_&&\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "[_&&\\d]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 8,
+                      "raw": "_&&\\d",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 8,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^[_&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^[_&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^[_&&\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "[_&&\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "[_&&\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 29,
+                      "raw": "_&&\\q{0|2|4|9\\uFE0F\\u20E3}",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      "right": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 29,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 9,
+                                "end": 10,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 11,
+                            "end": 12,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 11,
+                                "end": 12,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 13,
+                            "end": 14,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 14,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 15,
+                            "end": 28,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 15,
+                                "end": 16,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 16,
+                                "end": 22,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 22,
+                                "end": 28,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_&&_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^[_&&_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^[_&&_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^[_&&_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "[_&&_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "[_&&_]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassIntersection",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 7,
+                      "raw": "_&&_",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 7,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_--[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 16,
+        "raw": "/^[_--[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 14,
+          "raw": "^[_--[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 14,
+              "raw": "^[_--[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 13,
+                  "raw": "[_--[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 12,
+                    "raw": "[_--[0-9]]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 11,
+                      "raw": "_--[0-9]",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      "right": {
+                        "type": "CharacterClass",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 11,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 7,
+                            "end": 10,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 9,
+                              "end": 10,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 13,
+                  "end": 14,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 15,
+          "end": 16,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_--\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 13,
+        "raw": "/^[_--\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 11,
+          "raw": "^[_--\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 11,
+              "raw": "^[_--\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 10,
+                  "raw": "[_--\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 9,
+                    "raw": "[_--\\d]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 8,
+                      "raw": "_--\\d",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      "right": {
+                        "type": "CharacterSet",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 8,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 10,
+                  "end": 11,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 12,
+          "end": 13,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_--\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 34,
+        "raw": "/^[_--\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 32,
+          "raw": "^[_--\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 32,
+              "raw": "^[_--\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 31,
+                  "raw": "[_--\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 30,
+                    "raw": "[_--\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 29,
+                      "raw": "_--\\q{0|2|4|9\\uFE0F\\u20E3}",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      "right": {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 29,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 9,
+                                "end": 10,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 11,
+                            "end": 12,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 11,
+                                "end": 12,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 13,
+                            "end": 14,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 14,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 15,
+                            "end": 28,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 15,
+                                "end": 16,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 16,
+                                "end": 22,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 22,
+                                "end": 28,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 31,
+                  "end": 32,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 33,
+          "end": 34,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_--_]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 12,
+        "raw": "/^[_--_]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 10,
+          "raw": "^[_--_]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 10,
+              "raw": "^[_--_]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 9,
+                  "raw": "[_--_]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "ExpressionCharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 8,
+                    "raw": "[_--_]",
+                    "negate": false,
+                    "expression": {
+                      "type": "ClassSubtraction",
+                      "parent": "♻️..",
+                      "start": 3,
+                      "end": 7,
+                      "raw": "_--_",
+                      "left": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      "right": {
+                        "type": "Character",
+                        "parent": "♻️..",
+                        "start": 6,
+                        "end": 7,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 9,
+                  "end": 10,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 11,
+          "end": 12,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_[0-9]]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 14,
+        "raw": "/^[_[0-9]]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 12,
+          "raw": "^[_[0-9]]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 12,
+              "raw": "^[_[0-9]]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 11,
+                  "raw": "[_[0-9]]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 10,
+                    "raw": "[_[0-9]]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      {
+                        "type": "CharacterClass",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 9,
+                        "raw": "[0-9]",
+                        "unicodeSets": true,
+                        "negate": false,
+                        "elements": [
+                          {
+                            "type": "CharacterClassRange",
+                            "parent": "♻️../..",
+                            "start": 5,
+                            "end": 8,
+                            "raw": "0-9",
+                            "min": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 5,
+                              "end": 6,
+                              "raw": "0",
+                              "value": 48
+                            },
+                            "max": {
+                              "type": "Character",
+                              "parent": "♻️..",
+                              "start": 7,
+                              "end": 8,
+                              "raw": "9",
+                              "value": 57
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 11,
+                  "end": 12,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 13,
+          "end": 14,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_\\d]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 11,
+        "raw": "/^[_\\d]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 9,
+          "raw": "^[_\\d]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 9,
+              "raw": "^[_\\d]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 8,
+                  "raw": "[_\\d]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 7,
+                    "raw": "[_\\d]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      {
+                        "type": "CharacterSet",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 6,
+                        "raw": "\\d",
+                        "kind": "digit",
+                        "negate": false
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 8,
+                  "end": 9,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 10,
+          "end": 11,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[_\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 32,
+        "raw": "/^[_\\q{0|2|4|9\\uFE0F\\u20E3}]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 30,
+          "raw": "^[_\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 30,
+              "raw": "^[_\\q{0|2|4|9\\uFE0F\\u20E3}]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 29,
+                  "raw": "[_\\q{0|2|4|9\\uFE0F\\u20E3}]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 28,
+                    "raw": "[_\\q{0|2|4|9\\uFE0F\\u20E3}]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      {
+                        "type": "ClassStringDisjunction",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 27,
+                        "raw": "\\q{0|2|4|9\\uFE0F\\u20E3}",
+                        "alternatives": [
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 7,
+                            "end": 8,
+                            "raw": "0",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 7,
+                                "end": 8,
+                                "raw": "0",
+                                "value": 48
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 9,
+                            "end": 10,
+                            "raw": "2",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 9,
+                                "end": 10,
+                                "raw": "2",
+                                "value": 50
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 11,
+                            "end": 12,
+                            "raw": "4",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 11,
+                                "end": 12,
+                                "raw": "4",
+                                "value": 52
+                              }
+                            ]
+                          },
+                          {
+                            "type": "StringAlternative",
+                            "parent": "♻️../..",
+                            "start": 13,
+                            "end": 26,
+                            "raw": "9\\uFE0F\\u20E3",
+                            "elements": [
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 13,
+                                "end": 14,
+                                "raw": "9",
+                                "value": 57
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 14,
+                                "end": 20,
+                                "raw": "\\uFE0F",
+                                "value": 65039
+                              },
+                              {
+                                "type": "Character",
+                                "parent": "♻️../..",
+                                "start": 20,
+                                "end": 26,
+                                "raw": "\\u20E3",
+                                "value": 8419
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 29,
+                  "end": 30,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 31,
+          "end": 32,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    },
+    "/^[__]+$/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 10,
+        "raw": "/^[__]+$/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 8,
+          "raw": "^[__]+$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 8,
+              "raw": "^[__]+$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "Quantifier",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 7,
+                  "raw": "[__]+",
+                  "min": 1,
+                  "max": "$$Infinity",
+                  "greedy": true,
+                  "element": {
+                    "type": "CharacterClass",
+                    "parent": "♻️..",
+                    "start": 2,
+                    "end": 6,
+                    "raw": "[__]",
+                    "unicodeSets": true,
+                    "negate": false,
+                    "elements": [
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 3,
+                        "end": 4,
+                        "raw": "_",
+                        "value": 95
+                      },
+                      {
+                        "type": "Character",
+                        "parent": "♻️../..",
+                        "start": 4,
+                        "end": 5,
+                        "raw": "_",
+                        "value": 95
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 7,
+                  "end": 8,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 9,
+          "end": 10,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/top-level-await.json b/test/fixtures/parser/literal/test262/top-level-await.json
new file mode 100644
index 0000000..3773639
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/top-level-await.json
@@ -0,0 +1,125 @@
+{
+  "_test262FileNames": [
+    "test/language/module-code/top-level-await/await-expr-regexp.js",
+    "test/language/module-code/top-level-await/syntax/block-await-expr-regexp.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/1/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 3,
+        "raw": "/1/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "1",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "1",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "1",
+                  "value": 49
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 3,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/x.y/g": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/x.y/g",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "x.y",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "x.y",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "x",
+                  "value": 120
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "y",
+                  "value": 121
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "g",
+          "global": true,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/test262/u180e.json b/test/fixtures/parser/literal/test262/u180e.json
new file mode 100644
index 0000000..aec6549
--- /dev/null
+++ b/test/fixtures/parser/literal/test262/u180e.json
@@ -0,0 +1,324 @@
+{
+  "_test262FileNames": [
+    "test/built-ins/RegExp/dotall/without-dotall-unicode.js",
+    "test/built-ins/RegExp/dotall/without-dotall.js",
+    "test/language/literals/regexp/mongolian-vowel-separator.js"
+  ],
+  "options": {},
+  "patterns": {
+    "/^.$/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 5,
+        "raw": "/^.$/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "^.$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "^.$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 5,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^.$/m": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/^.$/m",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "^.$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "^.$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "m",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^.$/u": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 6,
+        "raw": "/^.$/u",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "^.$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "^.$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 6,
+          "raw": "u",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/^.$/um": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 7,
+        "raw": "/^.$/um",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 4,
+          "raw": "^.$",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 4,
+              "raw": "^.$",
+              "elements": [
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "^",
+                  "kind": "start"
+                },
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 2,
+                  "end": 3,
+                  "raw": ".",
+                  "kind": "any"
+                },
+                {
+                  "type": "Assertion",
+                  "parent": "♻️../..",
+                  "start": 3,
+                  "end": 4,
+                  "raw": "$",
+                  "kind": "end"
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 5,
+          "end": 7,
+          "raw": "um",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": true,
+          "unicode": true,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    },
+    "/᠎/": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 3,
+        "raw": "/᠎/",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 2,
+          "raw": "᠎",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 2,
+              "raw": "᠎",
+              "elements": [
+                {
+                  "type": "Character",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 2,
+                  "raw": "᠎",
+                  "value": 6158
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 3,
+          "end": 3,
+          "raw": "",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": false
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/unicode-group-names-valid.json b/test/fixtures/parser/literal/unicode-group-names-valid.json
index b786d47..e2f8e74 100644
--- a/test/fixtures/parser/literal/unicode-group-names-valid.json
+++ b/test/fixtures/parser/literal/unicode-group-names-valid.json
@@ -69,7 +69,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -138,7 +139,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -207,7 +209,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -276,7 +279,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -345,7 +349,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -414,7 +419,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     }
diff --git a/test/fixtures/parser/literal/unicode-property-escape-invalid-2024.json b/test/fixtures/parser/literal/unicode-property-escape-invalid-2024.json
new file mode 100644
index 0000000..c291d74
--- /dev/null
+++ b/test/fixtures/parser/literal/unicode-property-escape-invalid-2024.json
@@ -0,0 +1,20 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/\\P{Basic_Emoji}/v": {
+      "error": {
+        "message": "Invalid regular expression: /\\P{Basic_Emoji}/v: Invalid property name",
+        "index": 16
+      }
+    },
+    "/\\p{Basic_Emoji}/u": {
+      "error": {
+        "message": "Invalid regular expression: /\\p{Basic_Emoji}/u: Invalid property name",
+        "index": 15
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/parser/literal/unicode-property-escape-valid-2017.json b/test/fixtures/parser/literal/unicode-property-escape-valid-2017.json
index d50bee3..e8f2ab4 100644
--- a/test/fixtures/parser/literal/unicode-property-escape-valid-2017.json
+++ b/test/fixtures/parser/literal/unicode-property-escape-valid-2017.json
@@ -49,7 +49,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -106,7 +107,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -203,7 +205,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -308,7 +311,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     }
diff --git a/test/fixtures/parser/literal/unicode-property-escape-valid-2018.json b/test/fixtures/parser/literal/unicode-property-escape-valid-2018.json
index 9215e18..9d6ec1e 100644
--- a/test/fixtures/parser/literal/unicode-property-escape-valid-2018.json
+++ b/test/fixtures/parser/literal/unicode-property-escape-valid-2018.json
@@ -49,7 +49,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -106,7 +107,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -203,7 +205,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -308,7 +311,8 @@
           "unicode": false,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -340,6 +344,7 @@
                   "end": 10,
                   "raw": "\\p{ASCII}",
                   "kind": "property",
+                  "strings": false,
                   "key": "ASCII",
                   "value": null,
                   "negate": false
@@ -360,7 +365,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -392,6 +398,7 @@
                   "end": 10,
                   "raw": "\\p{Emoji}",
                   "kind": "property",
+                  "strings": false,
                   "key": "Emoji",
                   "value": null,
                   "negate": false
@@ -412,7 +419,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -444,6 +452,7 @@
                   "end": 28,
                   "raw": "\\p{General_Category=Letter}",
                   "kind": "property",
+                  "strings": false,
                   "key": "General_Category",
                   "value": "Letter",
                   "negate": false
@@ -464,7 +473,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -496,6 +506,7 @@
                   "end": 20,
                   "raw": "\\p{Script=Hiragana}",
                   "kind": "property",
+                  "strings": false,
                   "key": "Script",
                   "value": "Hiragana",
                   "negate": false
@@ -516,7 +527,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -547,6 +559,7 @@
                   "start": 1,
                   "end": 43,
                   "raw": "[\\p{Script=Hiragana}\\-\\p{Script=Katakana}]",
+                  "unicodeSets": false,
                   "negate": false,
                   "elements": [
                     {
@@ -556,6 +569,7 @@
                       "end": 21,
                       "raw": "\\p{Script=Hiragana}",
                       "kind": "property",
+                      "strings": false,
                       "key": "Script",
                       "value": "Hiragana",
                       "negate": false
@@ -575,6 +589,7 @@
                       "end": 42,
                       "raw": "\\p{Script=Katakana}",
                       "kind": "property",
+                      "strings": false,
                       "key": "Script",
                       "value": "Katakana",
                       "negate": false
@@ -597,7 +612,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     },
@@ -629,6 +645,7 @@
                   "end": 11,
                   "raw": "\\P{Letter}",
                   "kind": "property",
+                  "strings": false,
                   "key": "General_Category",
                   "value": "Letter",
                   "negate": true
@@ -649,7 +666,8 @@
           "unicode": true,
           "sticky": false,
           "dotAll": false,
-          "hasIndices": false
+          "hasIndices": false,
+          "unicodeSets": false
         }
       }
     }
diff --git a/test/fixtures/parser/literal/unicode-property-escape-valid-2024.json b/test/fixtures/parser/literal/unicode-property-escape-valid-2024.json
new file mode 100644
index 0000000..c7330c4
--- /dev/null
+++ b/test/fixtures/parser/literal/unicode-property-escape-valid-2024.json
@@ -0,0 +1,62 @@
+{
+  "options": {
+    "strict": false,
+    "ecmaVersion": 2024
+  },
+  "patterns": {
+    "/\\p{Basic_Emoji}/v": {
+      "ast": {
+        "type": "RegExpLiteral",
+        "parent": null,
+        "start": 0,
+        "end": 18,
+        "raw": "/\\p{Basic_Emoji}/v",
+        "pattern": {
+          "type": "Pattern",
+          "parent": "♻️..",
+          "start": 1,
+          "end": 16,
+          "raw": "\\p{Basic_Emoji}",
+          "alternatives": [
+            {
+              "type": "Alternative",
+              "parent": "♻️../..",
+              "start": 1,
+              "end": 16,
+              "raw": "\\p{Basic_Emoji}",
+              "elements": [
+                {
+                  "type": "CharacterSet",
+                  "parent": "♻️../..",
+                  "start": 1,
+                  "end": 16,
+                  "raw": "\\p{Basic_Emoji}",
+                  "kind": "property",
+                  "strings": true,
+                  "key": "Basic_Emoji",
+                  "value": null,
+                  "negate": false
+                }
+              ]
+            }
+          ]
+        },
+        "flags": {
+          "type": "Flags",
+          "parent": "♻️..",
+          "start": 17,
+          "end": 18,
+          "raw": "v",
+          "global": false,
+          "ignoreCase": false,
+          "multiline": false,
+          "unicode": false,
+          "sticky": false,
+          "dotAll": false,
+          "hasIndices": false,
+          "unicodeSets": true
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/visitor/full.json b/test/fixtures/visitor/full.json
index 64f54e6..02fb207 100644
--- a/test/fixtures/visitor/full.json
+++ b/test/fixtures/visitor/full.json
@@ -7996,6 +7996,254 @@
       "enter:Flags:u",
       "leave:Flags:u",
       "leave:RegExpLiteral:/\\P{Letter}/u"
+    ],
+    "/[A--B]/v": [
+      "enter:RegExpLiteral:/[A--B]/v",
+      "enter:Pattern:[A--B]",
+      "enter:Alternative:[A--B]",
+      "enter:ExpressionCharacterClass:[A--B]",
+      "enter:ClassSubtraction:A--B",
+      "enter:Character:A",
+      "leave:Character:A",
+      "enter:Character:B",
+      "leave:Character:B",
+      "leave:ClassSubtraction:A--B",
+      "leave:ExpressionCharacterClass:[A--B]",
+      "leave:Alternative:[A--B]",
+      "leave:Pattern:[A--B]",
+      "enter:Flags:v",
+      "leave:Flags:v",
+      "leave:RegExpLiteral:/[A--B]/v"
+    ],
+    "/[A--B--C]/v": [
+      "enter:RegExpLiteral:/[A--B--C]/v",
+      "enter:Pattern:[A--B--C]",
+      "enter:Alternative:[A--B--C]",
+      "enter:ExpressionCharacterClass:[A--B--C]",
+      "enter:ClassSubtraction:A--B--C",
+      "enter:ClassSubtraction:A--B",
+      "enter:Character:A",
+      "leave:Character:A",
+      "enter:Character:B",
+      "leave:Character:B",
+      "leave:ClassSubtraction:A--B",
+      "enter:Character:C",
+      "leave:Character:C",
+      "leave:ClassSubtraction:A--B--C",
+      "leave:ExpressionCharacterClass:[A--B--C]",
+      "leave:Alternative:[A--B--C]",
+      "leave:Pattern:[A--B--C]",
+      "enter:Flags:v",
+      "leave:Flags:v",
+      "leave:RegExpLiteral:/[A--B--C]/v"
+    ],
+    "/[A&&B&&C]/v": [
+      "enter:RegExpLiteral:/[A&&B&&C]/v",
+      "enter:Pattern:[A&&B&&C]",
+      "enter:Alternative:[A&&B&&C]",
+      "enter:ExpressionCharacterClass:[A&&B&&C]",
+      "enter:ClassIntersection:A&&B&&C",
+      "enter:ClassIntersection:A&&B",
+      "enter:Character:A",
+      "leave:Character:A",
+      "enter:Character:B",
+      "leave:Character:B",
+      "leave:ClassIntersection:A&&B",
+      "enter:Character:C",
+      "leave:Character:C",
+      "leave:ClassIntersection:A&&B&&C",
+      "leave:ExpressionCharacterClass:[A&&B&&C]",
+      "leave:Alternative:[A&&B&&C]",
+      "leave:Pattern:[A&&B&&C]",
+      "enter:Flags:v",
+      "leave:Flags:v",
+      "leave:RegExpLiteral:/[A&&B&&C]/v"
+    ],
+    "/[A--[B--C]]/v": [
+      "enter:RegExpLiteral:/[A--[B--C]]/v",
+      "enter:Pattern:[A--[B--C]]",
+      "enter:Alternative:[A--[B--C]]",
+      "enter:ExpressionCharacterClass:[A--[B--C]]",
+      "enter:ClassSubtraction:A--[B--C]",
+      "enter:Character:A",
+      "leave:Character:A",
+      "enter:ExpressionCharacterClass:[B--C]",
+      "enter:ClassSubtraction:B--C",
+      "enter:Character:B",
+      "leave:Character:B",
+      "enter:Character:C",
+      "leave:Character:C",
+      "leave:ClassSubtraction:B--C",
+      "leave:ExpressionCharacterClass:[B--C]",
+      "leave:ClassSubtraction:A--[B--C]",
+      "leave:ExpressionCharacterClass:[A--[B--C]]",
+      "leave:Alternative:[A--[B--C]]",
+      "leave:Pattern:[A--[B--C]]",
+      "enter:Flags:v",
+      "leave:Flags:v",
+      "leave:RegExpLiteral:/[A--[B--C]]/v"
+    ],
+    "/[A&&[B&&C]]/v": [
+      "enter:RegExpLiteral:/[A&&[B&&C]]/v",
+      "enter:Pattern:[A&&[B&&C]]",
+      "enter:Alternative:[A&&[B&&C]]",
+      "enter:ExpressionCharacterClass:[A&&[B&&C]]",
+      "enter:ClassIntersection:A&&[B&&C]",
+      "enter:Character:A",
+      "leave:Character:A",
+      "enter:ExpressionCharacterClass:[B&&C]",
+      "enter:ClassIntersection:B&&C",
+      "enter:Character:B",
+      "leave:Character:B",
+      "enter:Character:C",
+      "leave:Character:C",
+      "leave:ClassIntersection:B&&C",
+      "leave:ExpressionCharacterClass:[B&&C]",
+      "leave:ClassIntersection:A&&[B&&C]",
+      "leave:ExpressionCharacterClass:[A&&[B&&C]]",
+      "leave:Alternative:[A&&[B&&C]]",
+      "leave:Pattern:[A&&[B&&C]]",
+      "enter:Flags:v",
+      "leave:Flags:v",
+      "leave:RegExpLiteral:/[A&&[B&&C]]/v"
+    ],
+    "/[\\q{a|bc|def}]/v": [
+      "enter:RegExpLiteral:/[\\q{a|bc|def}]/v",
+      "enter:Pattern:[\\q{a|bc|def}]",
+      "enter:Alternative:[\\q{a|bc|def}]",
+      "enter:CharacterClass:[\\q{a|bc|def}]",
+      "enter:ClassStringDisjunction:\\q{a|bc|def}",
+      "enter:StringAlternative:a",
+      "enter:Character:a",
+      "leave:Character:a",
+      "leave:StringAlternative:a",
+      "enter:StringAlternative:bc",
+      "enter:Character:b",
+      "leave:Character:b",
+      "enter:Character:c",
+      "leave:Character:c",
+      "leave:StringAlternative:bc",
+      "enter:StringAlternative:def",
+      "enter:Character:d",
+      "leave:Character:d",
+      "enter:Character:e",
+      "leave:Character:e",
+      "enter:Character:f",
+      "leave:Character:f",
+      "leave:StringAlternative:def",
+      "leave:ClassStringDisjunction:\\q{a|bc|def}",
+      "leave:CharacterClass:[\\q{a|bc|def}]",
+      "leave:Alternative:[\\q{a|bc|def}]",
+      "leave:Pattern:[\\q{a|bc|def}]",
+      "enter:Flags:v",
+      "leave:Flags:v",
+      "leave:RegExpLiteral:/[\\q{a|bc|def}]/v"
+    ],
+    "/(?i-m:p)/": [
+      "enter:RegExpLiteral:/(?i-m:p)/",
+      "enter:Pattern:(?i-m:p)",
+      "enter:Alternative:(?i-m:p)",
+      "enter:Group:(?i-m:p)",
+      "enter:Modifiers:i-m",
+      "enter:ModifierFlags:i",
+      "leave:ModifierFlags:i",
+      "enter:ModifierFlags:m",
+      "leave:ModifierFlags:m",
+      "leave:Modifiers:i-m",
+      "enter:Alternative:p",
+      "enter:Character:p",
+      "leave:Character:p",
+      "leave:Alternative:p",
+      "leave:Group:(?i-m:p)",
+      "leave:Alternative:(?i-m:p)",
+      "leave:Pattern:(?i-m:p)",
+      "enter:Flags:",
+      "leave:Flags:",
+      "leave:RegExpLiteral:/(?i-m:p)/"
+    ],
+    "/(?ims:p)/u": [
+      "enter:RegExpLiteral:/(?ims:p)/u",
+      "enter:Pattern:(?ims:p)",
+      "enter:Alternative:(?ims:p)",
+      "enter:Group:(?ims:p)",
+      "enter:Modifiers:ims",
+      "enter:ModifierFlags:ims",
+      "leave:ModifierFlags:ims",
+      "leave:Modifiers:ims",
+      "enter:Alternative:p",
+      "enter:Character:p",
+      "leave:Character:p",
+      "leave:Alternative:p",
+      "leave:Group:(?ims:p)",
+      "leave:Alternative:(?ims:p)",
+      "leave:Pattern:(?ims:p)",
+      "enter:Flags:u",
+      "leave:Flags:u",
+      "leave:RegExpLiteral:/(?ims:p)/u"
+    ],
+    "/(?-ims:p)?/": [
+      "enter:RegExpLiteral:/(?-ims:p)?/",
+      "enter:Pattern:(?-ims:p)?",
+      "enter:Alternative:(?-ims:p)?",
+      "enter:Quantifier:(?-ims:p)?",
+      "enter:Group:(?-ims:p)",
+      "enter:Modifiers:-ims",
+      "enter:ModifierFlags:",
+      "leave:ModifierFlags:",
+      "enter:ModifierFlags:ims",
+      "leave:ModifierFlags:ims",
+      "leave:Modifiers:-ims",
+      "enter:Alternative:p",
+      "enter:Character:p",
+      "leave:Character:p",
+      "leave:Alternative:p",
+      "leave:Group:(?-ims:p)",
+      "leave:Quantifier:(?-ims:p)?",
+      "leave:Alternative:(?-ims:p)?",
+      "leave:Pattern:(?-ims:p)?",
+      "enter:Flags:",
+      "leave:Flags:",
+      "leave:RegExpLiteral:/(?-ims:p)?/"
+    ],
+    "/(?:no-modifiers)?/": [
+      "enter:RegExpLiteral:/(?:no-modifiers)?/",
+      "enter:Pattern:(?:no-modifiers)?",
+      "enter:Alternative:(?:no-modifiers)?",
+      "enter:Quantifier:(?:no-modifiers)?",
+      "enter:Group:(?:no-modifiers)",
+      "enter:Alternative:no-modifiers",
+      "enter:Character:n",
+      "leave:Character:n",
+      "enter:Character:o",
+      "leave:Character:o",
+      "enter:Character:-",
+      "leave:Character:-",
+      "enter:Character:m",
+      "leave:Character:m",
+      "enter:Character:o",
+      "leave:Character:o",
+      "enter:Character:d",
+      "leave:Character:d",
+      "enter:Character:i",
+      "leave:Character:i",
+      "enter:Character:f",
+      "leave:Character:f",
+      "enter:Character:i",
+      "leave:Character:i",
+      "enter:Character:e",
+      "leave:Character:e",
+      "enter:Character:r",
+      "leave:Character:r",
+      "enter:Character:s",
+      "leave:Character:s",
+      "leave:Alternative:no-modifiers",
+      "leave:Group:(?:no-modifiers)",
+      "leave:Quantifier:(?:no-modifiers)?",
+      "leave:Alternative:(?:no-modifiers)?",
+      "leave:Pattern:(?:no-modifiers)?",
+      "enter:Flags:",
+      "leave:Flags:",
+      "leave:RegExpLiteral:/(?:no-modifiers)?/"
     ]
   }
 }
\ No newline at end of file
diff --git a/test/fixtures/visitor/index.ts b/test/fixtures/visitor/index.ts
index c9317ca..3bb4213 100644
--- a/test/fixtures/visitor/index.ts
+++ b/test/fixtures/visitor/index.ts
@@ -1,45 +1,36 @@
 import fs from "fs"
 import path from "path"
+import type { EcmaVersion } from "../../../src/ecma-versions"
 
-type FixtureData = {
-    [filename: string]: {
+type FixtureData = Record<
+    string,
+    {
         options: {
             strict?: boolean
-            ecmaVersion?:
-                | 5
-                | 2015
-                | 2016
-                | 2017
-                | 2018
-                | 2019
-                | 2020
-                | 2021
-                | 2022
-        }
-        patterns: {
-            [source: string]: string[]
+            ecmaVersion?: EcmaVersion
         }
+        patterns: Record<string, string[]>
     }
-}
+>
 const fixturesRoot = __dirname
 
-export const Fixtures: FixtureData = fs
+export const fixturesData: FixtureData = fs
     .readdirSync(fixturesRoot)
-    .filter(filename => path.extname(filename) === ".json")
+    .filter((filename) => path.extname(filename) === ".json")
     .reduce<FixtureData>((fixtures, filename) => {
         fixtures[filename] = JSON.parse(
             fs.readFileSync(path.join(fixturesRoot, filename), "utf8"),
-            (_, v) => (v === "$$Infinity" ? Infinity : v),
-        )
+            (_, v: unknown) => (v === "$$Infinity" ? Infinity : v),
+        ) as FixtureData[string]
         return fixtures
     }, {})
 export function save(): void {
-    for (const filename of Object.keys(Fixtures)) {
+    for (const filename of Object.keys(fixturesData)) {
         fs.writeFileSync(
             path.join(fixturesRoot, filename),
             JSON.stringify(
-                Fixtures[filename],
-                (_, v) => (v === Infinity ? "$$Infinity" : v),
+                fixturesData[filename],
+                (_, v: unknown) => (v === Infinity ? "$$Infinity" : v),
                 2,
             ),
         )
diff --git a/test/parser.ts b/test/parser.ts
index 7a6d914..90c99df 100644
--- a/test/parser.ts
+++ b/test/parser.ts
@@ -1,15 +1,24 @@
 import assert from "assert"
-import { parseRegExpLiteral, RegExpParser } from "../src/index"
+import { parseRegExpLiteral, RegExpParser, RegExpValidator } from "../src/index"
+import type { RegExpSyntaxError } from "../src/regexp-syntax-error"
 import { cloneWithoutCircular } from "../scripts/clone-without-circular"
-import { Fixtures } from "./fixtures/parser/literal"
+import { fixturesData } from "./fixtures/parser/literal"
+import {
+    ASTERISK,
+    isLineTerminator,
+    LEFT_SQUARE_BRACKET,
+    REVERSE_SOLIDUS,
+    RIGHT_SQUARE_BRACKET,
+    SOLIDUS,
+} from "../src/unicode"
 
 function generateAST(source: string, options: RegExpParser.Options): object {
     return cloneWithoutCircular(parseRegExpLiteral(source, options))
 }
 
 describe("parseRegExpLiteral function:", () => {
-    for (const filename of Object.keys(Fixtures)) {
-        const fixture = Fixtures[filename]
+    for (const filename of Object.keys(fixturesData)) {
+        const fixture = fixturesData[filename]
         const options = fixture.options
 
         describe(`${filename} (options=${JSON.stringify(options)})`, () => {
@@ -40,20 +49,61 @@ describe("parseRegExpLiteral function:", () => {
                 } else {
                     it(`${source} should throw syntax error.`, () => {
                         const expected = result.error
-                        assert.strictEqual(
-                            expected.message.slice(0, 27),
-                            "Invalid regular expression:",
-                            `The error message '${expected.message}' was not syntax error.`,
-                        )
                         try {
                             parseRegExpLiteral(source, options)
                         } catch (err) {
-                            assert.strictEqual(err.message, expected.message)
-                            assert.strictEqual(err.index, expected.index)
+                            const error = err as RegExpSyntaxError
+                            assert.strictEqual(error.message, expected.message)
+                            assert.strictEqual(error.index, expected.index)
+
+                            assert.strictEqual(
+                                expected.message.slice(0, 27),
+                                "Invalid regular expression:",
+                                `The error message '${expected.message}' was not syntax error.`,
+                            )
                             return
                         }
                         assert.fail("Should fail, but succeeded.")
                     })
+
+                    const validator = new RegExpValidator(options)
+                    const extracted = extractPatternAndFlags(source, validator)
+                    if (extracted) {
+                        it(`${source} should throw syntax error with RegExpValidator#validatePattern.`, () => {
+                            const expected = result.error
+                            try {
+                                validator.validatePattern(
+                                    extracted.pattern,
+                                    undefined,
+                                    undefined,
+                                    {
+                                        unicode: extracted.flags.includes("u"),
+                                        unicodeSets:
+                                            extracted.flags.includes("v"),
+                                    },
+                                )
+                            } catch (err) {
+                                const error = err as RegExpSyntaxError
+                                const expectedMessage =
+                                    expected.message.replace(
+                                        /\/([a-z]+?):/u,
+                                        (_, flagsInLiteral: string) =>
+                                            `/${flagsInLiteral.replace(
+                                                /[^uv]/gu,
+                                                "",
+                                            )}:`,
+                                    )
+                                const expectedIndex = expected.index - 1
+                                assert.strictEqual(
+                                    error.message,
+                                    expectedMessage,
+                                )
+                                assert.strictEqual(error.index, expectedIndex)
+                                return
+                            }
+                            assert.fail("Should fail, but succeeded.")
+                        })
+                    }
                 }
             }
         })
@@ -77,3 +127,61 @@ describe("RegExpParser:", () => {
         })
     })
 })
+
+function extractPatternAndFlags(
+    source: string,
+    validator: RegExpValidator,
+): { pattern: string; flags: string } | null {
+    let inClass = false
+    let escaped = false
+
+    const chars = [...source]
+
+    if (chars[0] !== "/") {
+        return null
+    }
+    chars.shift()
+
+    const pattern: string[] = []
+
+    let first = true
+    // https://tc39.es/ecma262/2022/multipage/ecmascript-language-lexical-grammar.html#prod-RegularExpressionBody
+    for (;;) {
+        const char = chars.shift()
+        if (!char) {
+            return null
+        }
+        const cp = char.charCodeAt(0)!
+        if (isLineTerminator(cp)) {
+            return null
+        }
+        if (escaped) {
+            escaped = false
+        } else if (cp === REVERSE_SOLIDUS) {
+            escaped = true
+        } else if (cp === LEFT_SQUARE_BRACKET) {
+            inClass = true
+        } else if (cp === RIGHT_SQUARE_BRACKET) {
+            inClass = false
+        } else if (cp === ASTERISK && first) {
+            return null
+        } else if (cp === SOLIDUS && !inClass) {
+            break
+        }
+        pattern.push(char)
+        first = false
+    }
+
+    const flags = chars.join("")
+    if (pattern.length === 0) {
+        return null
+    }
+
+    try {
+        validator.validateFlags(flags)
+    } catch {
+        return null
+    }
+
+    return { pattern: pattern.join(""), flags }
+}
diff --git a/test/validate-error.ts b/test/validate-error.ts
new file mode 100644
index 0000000..4cf675b
--- /dev/null
+++ b/test/validate-error.ts
@@ -0,0 +1,176 @@
+import assert from "assert"
+import { RegExpValidator } from "../src/index"
+import type { RegExpSyntaxError } from "../src/regexp-syntax-error"
+
+const validator = new RegExpValidator()
+
+function getErrorForPattern(
+    source: string,
+    start: number,
+    end: number,
+    flags: {
+        unicode?: boolean
+        unicodeSets?: boolean
+    },
+): RegExpSyntaxError {
+    try {
+        validator.validatePattern(source, start, end, flags)
+    } catch (err) {
+        const error = err as RegExpSyntaxError
+        return error
+    }
+    return assert.fail("Should fail, but succeeded.")
+}
+
+function getErrorForFlags(
+    source: string,
+    start: number,
+    end: number,
+): RegExpSyntaxError {
+    try {
+        validator.validateFlags(source, start, end)
+    } catch (err) {
+        const error = err as RegExpSyntaxError
+        return error
+    }
+    return assert.fail("Should fail, but succeeded.")
+}
+
+function getErrorForLiteral(
+    source: string,
+    start: number,
+    end: number,
+): RegExpSyntaxError {
+    try {
+        validator.validateLiteral(source, start, end)
+    } catch (err) {
+        const error = err as RegExpSyntaxError
+        return error
+    }
+    return assert.fail("Should fail, but succeeded.")
+}
+
+describe("RegExpValidator#validatePattern error:", () => {
+    for (const test of [
+        {
+            source: "abcd",
+            start: 0,
+            end: 2,
+            flags: { unicode: true, unicodeSets: true },
+            error: {
+                message:
+                    "Invalid regular expression: /ab/uv: Invalid regular expression flags",
+                index: 3,
+            },
+        },
+        {
+            source: "[A]",
+            start: 0,
+            end: 2,
+            flags: { unicode: true, unicodeSets: false },
+            error: {
+                message:
+                    "Invalid regular expression: /[A/u: Unterminated character class",
+                index: 2,
+            },
+        },
+        {
+            source: "[[A]]",
+            start: 0,
+            end: 4,
+            flags: { unicode: false, unicodeSets: true },
+            error: {
+                message:
+                    "Invalid regular expression: /[[A]/v: Unterminated character class",
+                index: 4,
+            },
+        },
+        {
+            source: " /[[A]/v ",
+            start: 2,
+            end: 6,
+            flags: { unicode: false, unicodeSets: true },
+            error: {
+                message:
+                    "Invalid regular expression: /[[A]/v: Unterminated character class",
+                index: 6,
+            },
+        },
+    ]) {
+        it(`${JSON.stringify(test)} should throw syntax error.`, () => {
+            const error = getErrorForPattern(
+                test.source,
+                test.start,
+                test.end,
+                test.flags,
+            )
+            assert.deepStrictEqual(
+                { message: error.message, index: error.index },
+                test.error,
+            )
+        })
+    }
+})
+
+describe("RegExpValidator#validateFlags error:", () => {
+    for (const test of [
+        {
+            source: "abcd",
+            start: 0,
+            end: 2,
+            error: {
+                message: "Invalid regular expression: Invalid flag 'a'",
+                index: 0,
+            },
+        },
+        {
+            source: "dd",
+            start: 0,
+            end: 2,
+            error: {
+                message: "Invalid regular expression: Duplicated flag 'd'",
+                index: 0,
+            },
+        },
+        {
+            source: "/a/dd",
+            start: 3,
+            end: 5,
+            error: {
+                message: "Invalid regular expression: Duplicated flag 'd'",
+                index: 3,
+            },
+        },
+    ]) {
+        it(`${JSON.stringify(test)} should throw syntax error.`, () => {
+            const error = getErrorForFlags(test.source, test.start, test.end)
+            assert.deepStrictEqual(
+                { message: error.message, index: error.index },
+                test.error,
+            )
+        })
+    }
+})
+
+describe("RegExpValidator#validateLiteral error:", () => {
+    for (const test of [
+        {
+            source: " /[/ ",
+            start: 1,
+            end: 4,
+            error: {
+                message:
+                    "Invalid regular expression: /[/: Unterminated character class",
+                index: 4,
+            },
+        },
+    ]) {
+        it(`${JSON.stringify(test)} should throw syntax error.`, () => {
+            const error = getErrorForLiteral(test.source, test.start, test.end)
+            assert.deepStrictEqual(
+                { message: error.message, index: error.index },
+                test.error,
+            )
+        })
+    }
+})
diff --git a/test/visitor.ts b/test/visitor.ts
index d827540..92fa77e 100644
--- a/test/visitor.ts
+++ b/test/visitor.ts
@@ -1,20 +1,16 @@
 import assert from "assert"
-import {
-    AST,
-    RegExpParser,
-    parseRegExpLiteral,
-    visitRegExpAST,
-} from "../src/index"
+import type { AST, RegExpParser } from "../src/index"
+import { parseRegExpLiteral, visitRegExpAST } from "../src/index"
 import { cloneWithoutCircular } from "../scripts/clone-without-circular"
-import { Fixtures } from "./fixtures/visitor"
+import { fixturesData } from "./fixtures/visitor"
 
-function generateAST(source: string, options: RegExpParser.Options): any {
-    return cloneWithoutCircular(parseRegExpLiteral(source, options))
+function generateAST(source: string, options: RegExpParser.Options): AST.Node {
+    return cloneWithoutCircular(parseRegExpLiteral(source, options)) as AST.Node
 }
 
 describe("visitRegExpAST function:", () => {
-    for (const filename of Object.keys(Fixtures)) {
-        const fixture = Fixtures[filename]
+    for (const filename of Object.keys(fixturesData)) {
+        const fixture = fixturesData[filename]
         const options = fixture.options
 
         describe(`${filename} (options=${JSON.stringify(options)})`, () => {
@@ -39,11 +35,18 @@ describe("visitRegExpAST function:", () => {
                         onCharacterClassEnter: enter,
                         onCharacterClassRangeEnter: enter,
                         onCharacterSetEnter: enter,
+                        onClassIntersectionEnter: enter,
+                        onClassStringDisjunctionEnter: enter,
+                        onClassSubtractionEnter: enter,
+                        onExpressionCharacterClassEnter: enter,
                         onFlagsEnter: enter,
                         onGroupEnter: enter,
+                        onModifierFlagsEnter: enter,
+                        onModifiersEnter: enter,
                         onPatternEnter: enter,
                         onQuantifierEnter: enter,
                         onRegExpLiteralEnter: enter,
+                        onStringAlternativeEnter: enter,
                         onAlternativeLeave: leave,
                         onAssertionLeave: leave,
                         onBackreferenceLeave: leave,
@@ -52,11 +55,18 @@ describe("visitRegExpAST function:", () => {
                         onCharacterClassLeave: leave,
                         onCharacterClassRangeLeave: leave,
                         onCharacterSetLeave: leave,
+                        onClassIntersectionLeave: leave,
+                        onClassStringDisjunctionLeave: leave,
+                        onClassSubtractionLeave: leave,
+                        onExpressionCharacterClassLeave: leave,
                         onFlagsLeave: leave,
                         onGroupLeave: leave,
+                        onModifierFlagsLeave: leave,
+                        onModifiersLeave: leave,
                         onPatternLeave: leave,
                         onQuantifierLeave: leave,
                         onRegExpLiteralLeave: leave,
+                        onStringAlternativeLeave: leave,
                     })
 
                     assert.deepStrictEqual(history, expected)
diff --git a/tsconfig.eslint.json b/tsconfig.eslint.json
new file mode 100644
index 0000000..8fa6778
--- /dev/null
+++ b/tsconfig.eslint.json
@@ -0,0 +1,8 @@
+{
+    "extends": "./tsconfig.json",
+    "include": [
+        "scripts/**/*.ts",
+        "src/**/*.ts",
+        "test/**/*.ts",
+    ]
+}
diff --git a/tsconfig.json b/tsconfig.json
index 1348f1f..689e10d 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -13,7 +13,7 @@
         "esModuleInterop": true,
         "forceConsistentCasingInFileNames": true,
         "lib": [
-            "es2015"
+            "es2019"
         ],
         "module": "commonjs",
         "moduleResolution": "node",
@@ -33,7 +33,8 @@
         "strictFunctionTypes": true,
         "strictNullChecks": true,
         "strictPropertyInitialization": true,
-        "target": "es2015"
+        "target": "es2015",
+        "skipLibCheck": true
     },
     "include": [
         "src/**/*.ts"